less_retarded_wiki

by drummyfish, generated on 05/11/24, available under CC0 1.0 (public domain)

Hundred Rabbits

These motherfuckers are toxic SJWs, avoid them like the devil. For now see xxiivv.

21st Century

21st century, known as the Age Of Shit or Dark Ages, is already one of the worst centuries in history, despite only being around for a short time. Hell on Earth, violence, pure stupidity, destruction, hatred and greed, fascism, misery, torture and suffering -- these are just some words describing this time period of time. How unlucky it is to have been born in such a shitty time. Abominations walk in the streets. In this century there exists no more good, there is just evil opposed by another evil and people no longer even know what good means, they only support one of the two evils, thinking it's the good; there are rare few who support some kind of third evil that's not one of the two major evils, but all in all there is nothing but evil. While in the past only a portion of population were slaves, under today's late stage capitalism the whole population has already been enslaved. People are absurdly stupid, and everything is getting much worse by the year.

In 21st century there are already long established offices whose sole purpose is to ensure people cannot make use of useful ideas (see patents). It is also possible -- and actually extremely common -- to draw a rectangle on the ground and then buy a paper that makes it possible to bully anyone who enters that rectangle, even kill him. Whole earth is now covered with such rectangles, it is impossible to set foot anywhere else -- in fact if you want to live, you have to buy a paper that gives you your own rectangle where you won't be bullied if you fall asleep, but you have to continuously pay for that paper, i.e. you are doomed to slavery just by existing. In 21 century it is forbidden to shit or urinate if you have no money in your pocket, without money you are OFFICIALLY supposed and expected to hold it until your bladder explodes and you die in the street -- if you're in a big city and you want to shit, you cannot do it, you may only pay for someone to let you take a shit in his house. Also in 21st century you cannot eat food that is next to you, that no one else is eating and that will be thrown away, and that even if you're starving -- it is called theft and you will be beaten for it, maybe even killed. In this century you can also no longer drink from rivers or lakes, they have been poisoned so that you cannot drink at all if you don't have money in your pocket -- doing the same with air is already work in progress, major cities already have borderline unbreathable air. Never ending torture is part of everyday life: for example every day you are forced to stop sleeping very early and go perform slavery that you hate deeply, the whole day you are continuously targeted with repeated brainwashing (ads, news, social media, fear culture, industrial noise, ...) that equate psychological torture. There are many more things like this but trying to recount them all would result in many thousands of billions of volumes of books.

3D Modeling

The topic of 3D modeling will be part of article about 3D models.

3D Model

In the world of computers (especially in computer graphics, but also in physics simulations, 3D printing etc.) 3D model is a representation of a three dimensional object, for example of a real life object such as a car, tree or a dog, but also possibly something more abstract like a fractal or function plot surface. 3D models can be displayed using various 3D rendering techniques and are used mostly to simulate real world on computers (e.g. games), as real world is, as we know, three dimensional. 3D models can be created in several ways, e.g. manually with 3D modeling software (such as Blender) by 3D artists, by 3D scanning real world objects, or automatically by procedural generation.

There is a plethora of different 3D model types, the topic is very large when viewed in its whole scope because 3D models can be used and represented in many ways (and everything is yet more complex by dealing with different methods of 3D rendering) -- the mainstream "game" 3D models that most people are used to seeing are polygonal (basically made of triangles) boundary-representation (recording only surface, not volume) textured (with "pictures" on their surface) 3D models, but be aware that many different ways of representation are possible and in common use by the industry, for example various volume representations, voxel models, point clouds, implicit surfaces, spline surfaces, constructive solid geometry, wireframe etc. Models may also bear additional extra information and features, e.g. material, bone rigs for animation, animation key frames, density information, LODs, even scripts and so on.

3D formats: situation here is not as simple as it is with images or audio, but there are a few formats that in practice will suffice for most of your models. Firstly the most KISS one is (Wavefront) obj -- this is supported by almost every 3D software, it's a text format that's easy to parse and it's even human readable and editable; obj supports most things you will ever need like UV maps and normals, and you can hack it even for a primitive keyframe animation. So if you can, use obj as your first choice. If you need something a little more advanced, use COLLADA (.dae extension) -- this is a bit more bloated than obj as it's an XML, but it's still human readable and has more features, for example skeletal animation, instancing, model hierarchy and so on. Another noteworthy format is e.g. stl used a lot in 3D printing. For other than polygonal models you may have to search a bit or just represent your model in some sane way, for example heightmap is naturally saved as a grayscale image, voxel model may be saved in some dead simple text format and so on. Also be always sure to distribute your model in universal format, i.e. don't just share Blender's project file or anything like that, that's like sharing pictures in Photoshop format or sending someone a Word document, only retards do that -- yes, you should also share the project file if possible, but it's more important to release the model in a widely supported, future proof and non discriminating format.

Let's now take a closer look at a basic classification of 3D models (we only mention the important categories, this is not an exhaustive list):

• by representation:
  • boundary representation: Captures only the object's boundary, i.e. its surface, so we really end up with just a hollow "shell" of the object without any volume inside. This is mostly good enough for programs such as games -- with opaque objects we only ever see their surface anyway (with transparent objects we get into a bit of trouble but can still manage to "fake" some convincing look).
    • smooth spline surfaces: Model the boundary with smooth mathematical function, poplar are e.g. NURBS. This gives very nice models that even up close look completely smooth. Disadvantage is that it's not so easy to render these models directly in real time, so the models are typically converted to polygonal models during rendering anyway, sometimes using things like adaptive subdivision to still keep the model as smooth as possible.
    • polygonal: The surface is represented with polygons such as triangles or quads that are connected to each other by their edges. These models have sharp edges and to look smooth have to make use of many polygons, but it turns out this representation is convenient, they can be easily edited and most importantly quickly rendered in real time, which is why most game 3D models use this representation. These models are composed of three essential elements: vertices (points in space), edges (lines connecting the vertices) and polygons (flat surfaces between the edges).
      • triangular: Polygonal models that only contain triangles (three sided polygons), oftentimes automatically created from general polygonal models. Models are normally automatically triangulated right before rendering because a GPU can basically just draw triangles.
    • ...
  • volume representation: Explicitly provide information about the whole object's volume, i.e. it is possible to tell if any point is inside the model or outside of it and additionally usually also providing more information e.g. about density, material, index of refraction and so on. Such models naturally allow more precise simulations, they may fit better into physics engines and can also naturally be nicely rendered with raytracting and similar image order rendering methods. For real time entertainment graphics this is mostly overkill and the model would have to be converted to boundary representation anyway, so volumetric models are rather used in science and engineering industry.
    • voxel: Analogy of 2D bitmap images extended to 3D, i.e. the model exists in a 3D grind and is represented with small cubes called voxels (3D analog to 2D pixel). The model is therefore rough with "staircases" -- this is very famously seen in the game Minecraft, but is very common also e.g. in medical devices like MRI which scan human body as a series of layers, each one captured essentially as a 2D image. Voxel models are convenient for various dynamic simulations, cellular automata, procedural generation and so on. Voxel models can be converted to other types of model, e.g. to polygonal ones (see the Marching Cubes algorithm).
    • constructive solid geometry (CSG): Represent the model as a tree (or a more general hierarchical graph) of basic geometric shapes combined together with so called boolean operations -- basically set operations like union, subtraction and so on. This is widely used in CAD applications for variety of reasons, e.g. the models are quite precise and smooth, easily parametrized, their description is similar to their physical manufacturing by machines (e.g. "make a sphere, dig hole in it", ...) and so on.
    • implicit surfaces, signed distance function: Describe the model by a distance function, i.e. function f(x,y,z) which for any point in space says the distance to the object's boundary, with this distance being negative inside the object. This has some nice advanced use cases.
    • heightmaps: Typically used for modeling terrain, represent terrain height at each 2D coordinate, normally with a grayscale bitmap image. Advantages include simplicity of representation and the ability to edit the heightmap with image editing tools, among disadvantages are limited resolution of the heightmap and inability to represent e.g. overhangs.
    • ...
  • point cloud: Captures only individual points, sometimes with additional attributes such as color of each point, something akin its size, orientation and so on. This is typically what we get as raw data from some 3D scanners (see photogrammetry). The advantage of point clouds is simplicity, they can be relatively easily rendered (just by drawing points on the screen), disadvantage is that the model has no surface and volume, there are "holes" in it: point cloud therefore has to be very dense to really be useful and for that it can take a lot of storage space. Point clouds may be converted to a more desirable format with special algorithms.
  • wireframe: Records only edges, again potentially with attributes like their color etc. Just as with point clouds wireframe model has no surface or volume, but it at least has some information about which points are interconnected. Nowadays wireframe is not so much used as a model representation but rather as one of viewing modes.
• by features:
  • UV mapped: Having UV map, i.e. being ready to be textured.
  • textured: Having one or more textures.
  • rigged: Having bone rig set up for skeletal animation.
  • animated: Having predefined animation (e.g. idle, running, attacking, ...).
  • with materials: Having one or more materials defined and assigned to parts of the model. Materials define properties such as texture, metalicity, transparency and so on.
  • with smoothing groups: Having information important for correct shading (so that sharp edges look sharp and smooth edges look smooth).
  • with subdivision weights: Having information that's important for correct automatic subdivision (geometrical smoothing).
  • ...
• by detail, resolution and fidelity:
  • low poly: Relatively low total count of polygons.
  • mid poly: Polygon count somewhere between low and high poly.
  • high poly: Relatively high total count of polygons.
  • ...
• by artistic style:
  • realistic
  • stylized
  • abstract
  • ...
• by intended use:
  • real time: Made for real time graphic, i.e. optimized for speed.
  • offline: Made for offline rendering, optimized for detail and visual quality.
  • for animation: Made with animation in mind -- this requires extra effort on correct topology so that the model deforms well.
  • ...

Animation: the main approaches to animation are these (again, just the important ones, you may encounter other ways too):

• model made of separate parts: Here we make a bigger model out of smaller models (i.e. body is head plus torso plus arms plus legs etc.) and then animate the big model by transforming the small models. This is very natural e.g. for animating machines, for example the wheels of a car, but characters were animated this way too (see e.g. Morrowind). The advantage is that you don't need any sophisticated subsystem for deforming models or anything, you just move models around (though it's useful to at least have parenting of models so that you can attach models to stick together). But it can look bad and there may be some ugliness like models intersecting etc.
• keyframe morphing: The mostly sufficient KISS way based on having a few model "poses" and just interpolating between them -- i.e. for example a running character may have 4 keyframes: legs together, right leg in front, legs together, left leg in front; now to make smooth animation we just gradually deform one keyframe into the next. Now let's stress that this is a single model, each keyframe is just differently shaped, i.e. its vertices are at different positions, so the model is animating by really being deformed into different shapes. This was used in old games like Quake, it looks good and works well -- use it if you can.
• skeletal animation: The mainstream, gigantically bloated way, used in practically all 3D games since about 2005. Here we firstly make a skeleton for the model, i.e. an additional "model made of sticks (so called bones)" and then we have to painstakingly rig (or skin) the model, i.e. we attach the skeleton to the model (more technically assign weights to the model's vertices so as to make them deform correctly). Now we have basically a puppet we can move quite easily: if we move the arm bone, the whole arm moves and so on. Now animations are still made with keyframes (i.e. making poses in certain moments in time between which we interpolate), the advantage against morphing is just that we don't have to manually reshape the model on the level of individual vertices, we only manipulate the bones and the model deforms itself, so it's a bit more comfortable but this requires firstly much more work and secondly there needs to be a hugely bloated skeletal system programmed in (complex math, complex model format, skinning GUI, ...). Bones have more advantages, you can e.g. make procedural animations, ragdoll physics, you can attach things like weapon to the bones etc., but it's mostly not worth it. Even if you have a rigged skeletal model, you can still export its animation in the simple keyframe morphing format so as to at least keep your engine simple. Though skeletal animation was mostly intended for characters, nowadays it's just used for animating everything (like book pages have their own bones etc.) because many engines don't even support anything simpler.

Let us also briefly mention texturing, an important part of making traditional 3D models. In the common, narrower sense texture is a 2D images that is stretched onto the model surface to give the model more detail, just like we put wallpaper on a wall -- without textures our models have flat looking surfaces with just a constant color (at best we may assign each polygon a different color, but that won't make for a very realistic model). Putting texture on the model is called texture mapping -- you may also hear the term UV mapping because texturing is essential about making what we call a UV map. This just means we assign each model vertex 2D coordinates inside the texture; we traditionally call these two coordinates U and V, hence the term UV mapping. UV coordinates are just coordinates within the texture image; they are not in pixels but are typically normalized to a float in range <0,1> (i.e. 0.5 meaning middle of the image etc.) -- this is so as to stay independent of the texture resolution (you can later swap the texture for a different resolution one and it will still work). By assigning each vertex its UV texture coordinates we basically achieve the "stretching", i.e. we say which part of the texture will show on what's the character's face etc. (Advanced note: if you want to allow "tears" in the texture, you have to assign UV coordinates per triangle, not per vertex.) Now let's also mention a model can have multiple textures at once -- the most basic one (usually called diffuse) specifies the surface color, but additional textures may be used for things like transparency, normals (see normal mapping), displacement, material properties like metalicity and so on (see also PBR). The model may even have multiple UV maps, the UV coordinates may be animated and so on and so forth. Finally we'll also say that there exists 3D texturing that doesn't use images, 3D textures are mostly procedurally generated, but this is beyond our scope now.

We may do many, many more things with 3D models, for example subdivide them (automatically break polygons down into more polygons to smooth them out), apply boolean operations to them (see above), sculpt them (make them from virtual clay), optimize them (reduce their polygon count, make better topology, ...), apply various modifiers, 3D print them, make them out of paper (see origami) etcetc.

{ Holy crab, there is a lot to say about 3D models. ~drummyfish }

Example

Let's take a look at a simple polygonal 3D model. The following is a primitive, very low poly model of a house, basically just a cube with roof:

               I
             .:..  
           .' :':::..
        _-' H.' '.   ''-. 
      .'    .:...'.......''..G
    .' ...'' :    '.    ..' :
  .::''......:.....'.-''    :
 E:          :      :F      :
  :          :      :       :
  :          :      :       :
  :          :......:.......:
  :        .' D     :     .' C    
  :     .''         :   -'
  :  .''            : .'
  ::'...............:'
 A                   B

In a computer it would firstly be represented by an array of vertices, e.g.:

-2 -2 -2  (A)
 2 -2 -2  (B)
 2 -2  2  (C)
 2 -2 -2  (D)
-2  2 -2  (E)
 2  2 -2  (F)
 2  2  2  (G)
 2  2 -2  (H)
 0  3  0  (I)

Along with triangles (specified as indices into the vertex array, here with letters):

ABC ACD          (bottom)
AFB AEF          (front wall)
BGC BFG          (right wall)
CGH CHD          (back wall)
DHE DEA          (left wall)
EIF FIG GIH HIE  (roof)  

We see the model consists of 9 vertices and 14 triangles. Notice that the order in which we specify triangles follows the rule that looking at the front side of the triangle its vertices are specified clockwise (or counterclockwise, depending on chosen convention) -- sometimes this may not matter, but many 3D engines perform so called backface culling, i.e. they only draw the front faces and there some faces would be invisible from the outside if their winding was incorrect, so it's better to stick to the rule if possible.

The following is our house model in obj format -- notice how simple it is (you can copy paste this into a file called house.obj and open it in Blender):

# simple house model
v 2.000000 -2.000000 -2.000000
v 2.000000 -2.000000 2.000000
v -2.000000 -2.000000 2.000000
v -1.999999 -2.000000 -2.000000
v 2.000001 2.000000 -2.000000
v 1.999999 2.000000 2.000000
v -2.000001 2.000000 2.000000
v -2.000000 2.000000 -2.000000
v -2.000001 2.000000 2.000000
v 0.000000 3.000000 0.000000
vn 1.0000 0.0000 0.0000
vn -0.0000 0.0000 1.0000
vn 0.0000 -1.0000 0.0000
vn 0.0000 0.0000 -1.0000
vn -1.0000 -0.0000 -0.0000
vn -0.0000 0.8944 0.4472
vn 0.4472 0.8944 0.0000
vn 0.0000 0.8944 -0.4472
vn -0.4472 0.8944 -0.0000
s off
f 6 2 5
f 2 1 5
f 6 9 3
f 3 2 6
f 4 1 3
f 2 3 1
f 5 1 8
f 4 8 1
f 8 4 9
f 4 3 9
f 9 6 10
f 6 5 10
f 8 10 5
f 8 9 10

And here is the same model again, now in collada format (it is an XML so it's much more verbose, again you can copy paste this to a file house.dae and open it in Blender):

<?xml version="1.0" encoding="utf-8"?>
<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!-- simple house model -->
  <asset>
    <contributor> <author>drummyfish</author> </contributor>
    <unit name="meter" meter="1"/>
    <up_axis>Z_UP</up_axis>
  </asset>
  <library_geometries>
    <geometry id="house-mesh" name="house">
      <mesh>
        <source id="house-mesh-positions">
          <float_array id="house-mesh-positions-array" count="30">
             2  2 -2      2 -2 -2      -2 -2 -2      -2  2 -2
             2  2  2      2 -2  2      -2 -2  2      -2  2  2
            -2 -2  2      0  0  3
          </float_array>
          <technique_common>
            <accessor source="#house-mesh-positions-array" count="10" stride="3">
              <param name="X" type="float"/>
              <param name="Y" type="float"/>
              <param name="Z" type="float"/>
            </accessor>
          </technique_common>
        </source>
        <vertices id="house-mesh-vertices">
          <input semantic="POSITION" source="#house-mesh-positions"/>
        </vertices>
        <triangles material="Material-material" count="14">
          <input semantic="VERTEX" source="#house-mesh-vertices" offset="0"/>
          <p>
            5 1 4   1 0 4    5 8 2    2 1 5    3 0 2    1 2 0    4 0 7
            3 7 0   7 3 8    3 2 8    8 5 9    5 4 9    7 9 4    7 8 9
          </p>
        </triangles>
      </mesh>
    </geometry>
  </library_geometries>
  <library_visual_scenes>
    <visual_scene id="Scene" name="Scene">
      <node id="house" name="house" type="NODE">
        <translate sid="location">0 0 0</translate>
        <rotate sid="rotationZ">0 0 1 0</rotate>
        <rotate sid="rotationY">0 1 0 0</rotate>
        <rotate sid="rotationX">1 0 0 0</rotate>
        <scale sid="scale">1 1 1</scale>
        <instance_geometry url="#house-mesh" name="house"/>
      </node>
    </visual_scene>
  </library_visual_scenes>
  <scene> <instance_visual_scene url="#Scene"/> </scene>
</COLLADA>

TODO: other types of models, texturing etcetc.

3D Modeling: Learning It And Doing It Right

WORK IN PROGRESS

Do you want to start 3D modeling? Or do you already know a bit about it and just want some advice to get better? Then let us share a few words of advice here.

Let us preface with mentioning the hacker chad way of making 3D models, i.e. the LRS way 3D models should ideally be made. Remeber, you don't need any program to create 3D models, you don't have to be a Blender whore, you can make 3D models perfectly fine without Blender or any similar program, and even without computers. Sure, a certain kind of highly artistic, animated, very high poly models will be very hard or impossible to make without an interactive tool like Blender, but you can still make very complex 3D models, such as that of a whole city, without any fancy tools. Of course people were making statues and similar kinds of "physical 3D models" for thousands of years -- sometimes it's actually simpler to make the model by hand out of clay and later scan it into the computer, you can just make a physical wireframe model, measure the positions of vertices, hand type them into a file and you have a perfectly valid 3d model -- you may also easily make a polygonal model out of paper, BUT even virtual 3D models can simply be made with pen and paper, it's just numbers, vertices and triangles, very manageable if you keep it simple and well organized. You can directly write the models in text formats like obj or collada. First computer 3D models were actually made by hand, just with pen and paper, because there were simply no computers fast enough to even allow real time manipulation of 3D models; back then the modelers simply measured positions of someone object's "key points" (vertices) in 3D space which can simply be done with tools like rulers and strings, no need for complex 3D scanners (but if you have a digital camera, you have a quite advanced 3D scanner already). They then fed the manually made models to the computer to visualize them, but again, you don't even need a computer to draw a 3D model, in fact there is a whole area called descriptive geometry that's all about drawing 3D models on paper and which was used by engineers before computers came. Anyway, you don't have to go as far as avoiding computers of course -- if you have a programmable computer, you already have the luxury which the first 3D artists didn't have, a whole new world opens up to you, you can now make very complex 3D models just with your programming language of choice. Imagine you want to make the said 3D model of a city just using the C programming language. You can first define the terrain as heightmap simply as a 2D array of numbers, then you write a simple code that will iterate over this array and converts it to the obj format (a very simple plain text 3D format, it will be like 20 lines of code) -- now you have the basic terrain, you can render it with any tool that can load 3D models in obj format (basically every 3D tool), AND you may of course write your own 3D visualizer, there is nothing difficult about it, you don't even have to use perspective, just draw it in orthographic projection (again, that will be probably like 20 lines of code). Now you may start adding houses to your terrain -- make a C array of vertices and another array of triangle indices, manually make a simple 3D model of a house (a basic shape will have fewer than 20 vertices, you can cut it out of paper to see what it will look like). That's your house geometry, now just keep making instances of this house and placing them on the terrain, i.e. you make some kind of struct that will keep the house transformation (its position, rotation and scale) and each such struct will represent one house having the geometry you created (if you later improve the house model, all houses will be updates like this). You don't have to worry about placing the houses vertically, their height will be computed automatically so they sit right on the terrain. Now you can update your model exporter to take into account the houses, it will output the obj model along with them and again, you can view this whole model in any 3D software or with your own tools. You can continue by adding trees, roads, simple materials (maybe just something like per triangle colors) and so on. This approach may actually even be superior for some projects just as scripting is superior to many GUI programs, you can collaborate on this model just like you can collaborate on any other text program, you can automatize things greatly, you'll be independent of proprietary formats and platforms etcetc. This is how 3D models would ideally be made.

OK, back to the mainstream now. Nowadays as a FOSS user you will most likely do 3D modeling with Blender -- we recommended it to start learning 3D modeling as it is powerful, free, gratis, has many tutorials etc. Do NOT use anything proprietary no matter what anyone tells you! Once you know a bit about the art, you may play around with alternative programs or approaches (such as writing programs that generate 3D models etc.). However as a beginner just start with Blender, which is from now on in this article the software we'll suppose you're using.

Start extremely simple and learn bottom-up, i.e. learn about fundamentals and low level concepts and start with very simple models (e.g. simple untextured low-poly shape of a house, box with a roof), keep creating more complex models by small steps. Do NOT fall into the trap of "quick and easy magic 3D modeling" such as sculpting or some "smart apps" without knowing what's going on at the low level, you'll end up creating extremely ugly, inefficient models in bad formats, like someone wanting to create space rockets without learning anything about math or physics first. Remember to practice, practice, practice -- eventually you learn by doing, so try to make small projects and share your results on sites such as opengameart to get feedback and some mental satisfaction and reward for your effort. The following is an outline of possible steps you may take towards becoming an alright 3D artist:

1. Learn what 3D model actually is, basic technical details about how a computer represents it and roughly how 3D rendering works. It is EXTREMELY important to have at least some idea about the fundamentals, i.e. you should learn at least the following:

• 3D models that are used today consist of vertices and triangles (though higher polygons are usually supported in modeling software, everything is broken down to triangles eventually), computers usually store arrays of vertices and triangles as indices pointing to the array of vertices. Triangles have facing (front and back side, determined by the order of its vertices). These 3D models only represent the boundary (not the volume). All this is called the model's geometry.
• Normals are vectors "perpendicular to the surface", they can be explicitly modified and stored or computed automatically and they are extremely important because they say how the model interacts with light (they are used in shading of the model), i.e. which edges appear sharp or smooth. Normal maps are textures that can be used to modify normals to make the surface seem rough or otherwise deformed without actually modifying the geometry. You HAVE TO understand normals.
• Textures are images (or similar image-like data) that can be mapped to the model surface to "paint it" (or give it other material properties). They are mapped to models by giving vertices texturing UV coordinates. To make textures you'll need some basics of 2D image editing (see e.g. GIMP).
• 3D rendering (and also modeling) works with the concept of a scene in which a number of models reside, as well as a virtual camera (or multiple ones), lights and other objects. These objects have transformations (normally translation, rotation and scale, represented by matrices) and may form a hierarchy, so called scene graph (some objects may be parents of other objects, meaning the child transformations are relative to parents) etc.
• A 3D renderer will draw the triangles the model consists of by applying shading to determine color of each pixel of the rasterized triangle. Shading takes into account besides others texture(s) of the model, its material properties and light falling on the model (in which the model normals play a big role). Shading can be modified by creating shaders (if you don't create custom shaders, some default one will be used).
• Briefly learn about other concepts such as low/high poly modeling and basic 3D formats such as OBJ and COLLADA (which features they support etc.), possible other models representations (voxels, point clouds, ...) etc.

2. Manually create a few extremely simple low-poly untextured models, e.g. that of a simple house, laptop, hammer, bottle etc. Keep the vertex and triangle count very low (under 100), make the model by MANUALLY creating every vertex and triangle and focus only on learning this low level geometry manipulation well (how to create a vertex, how to split an edge, how to rotate a triangle, ...), making the model conform to good practice and get familiar with tools you're using, i.e. learn the key binds, locking movement direction to principal axes, learn manipulating your 3D view, setting up the free/side/front/top view with reference images etc. Make the model nice! I.e. make it have correctly facing triangles (turn backface culling on to check this), avoid intersecting triangles, unnecessary triangles and vertices, remove all duplicate vertices (don't have multiple vertices with the same position), connect all that should be connected, avoid badly shaped triangles (e.g. extremely acute/long ones) etc. Also learn about normals and make them nice! I.e. try automatic normal generation (fiddle e.g. with angle thresholds for sharp/smooth edges), see how they affect the model look, try manually marking some edges sharp, try out smoothing groups etc. Save your final models in OBJ format (one of the simplest and most common formats supporting all you need at this stage). All this will be a lot to learn, that's why you must not try to create a complex model at this stage. You can keep yourself "motivated" e.g. by aiming for creating a low-poly model collection you can share at opengameart or somewhere :)
3. Learn texturing -- just take the models you have and try to put a simple texture on them by drawing a simple image, then unwrapping the UV coordinates and MANUALLY editing the UV map to fit on the model. Again the goal is to get familiar with the tools and concepts now; experiment with helpers such as unwrapping by "projecting from 3D view", using "smart" UV unwrap etc. Make the UV map nice! Just as model geometry, UV maps also have good practice -- e.g. you should utilize as many texture pixels as possible (otherwise you're wasting space in the image), watch out for color bleeding, the mapping should have kind of "uniform pixel density" (or possibly increased density on triangles where more details is supposed to be), some pixels of the texture may be mapped to multiple triangles if possible (to efficiently utilize them) etc. Only make a simple diffuse texture (don't do PBR, material textures etc., that's too advanced now). Try out texture painting and manual texture creation in a 2D image program, get familiar with both.
4. Learn modifiers and advanced tools. Modifiers help you e.g. with the creation of symmetric models: you only model one side and the other one gets mirrored. Subdivide modifier will automatically create a higher poly version of your model (but you need to help it by telling it which sides are sharp etc.). Boolean operations allow you to apply set operations like unification or subtraction of shapes (but usually create a messy geometry you have to repair!). There are many tools, experiment and learn about their pros and cons, try to incorporate them to your modeling.
5. Learn retopology and possibly sculpting. Topology is an extremely important concept -- it says what the structure of triangles/polygons is, how they are distributed, how they are connected, which curves their edges follow etc. Good topology has certain rules (e.g. ideally only being composed of quads, being denser where the shape has more detail and sparser where it's flat, having edges so that animation won't deform the model badly etc.). Topology is important for efficiency (you utilize your polygon budget well), texturing and especially animation (nice deformation of the model). Creating more complex models is almost always done in the following two steps:

• Creating the shape while ignoring topology, for example with sculpting (but also other techniques, e.g. just throwing shapes together). The goal is to just make the desired shape.
• Retopology: creating a nice topology for the shape while keeping the shape unchanged. This is done by starting modeling from the start with the "stick to surface" option, i.e. whenever you create or move a vertex, it sticks to the nearest surface (surface of the created shape). Here you just try to create a new "envelope" on the existing shape while focusing on making the envelope's topology nice.

6. Learn about materials and shaders. At this point you may learn about how to create custom shaders, how to create transparent materials, apply multiple textures, how to make realistic skin, PBR shaders etc. You should at least be aware of basic shading concepts and commonly encountered techniques such as Phong shading, subsurface scattering, screen space effects etc. because you'll encounter them in shader editors and you should e.g. know what performance penalties to expect.
7. Learn animation. First learn about keyframes and interpolation and try to animate basic transformations of a model, e.g. animate a car driving through a city by keyframing its position and rotation. Then learn about animating the model's geometry -- first the simple, old way of morphing between different shapes (shape keys in Blender). Finally learn the hardest type of animation: skeletal animation. Learn about bones, armatures, rigging, inverse kinematics etc.
8. Now you can go crazy and learn all the uber features such as hair, physics simulation, NURBS surfaces, boob physics etc.

Don't forget to stick to LRS principles! This is important so that your models are friendly to good technology. I.e. even if "modern" desktops don't really care about polygon count anymore, still take the effort to optimize your model so as to not use more polygons that necessary! Your models may potentially be used on small, non-consumerist computers with software renderers and low amount of RAM. Low-poly is better than high-poly (you can still prepare your model for automatic subdivision so that obtaining a higher poly model from it automatically is possible). Don't use complex stuff such as PBR or skeletal animation unless necessary -- you should mostly be able to get away with a simple diffuse texture and simple keyframe morphing animation, just like in old games! If you do use complex stuff, make it optional (e.g. make a normal map but don't rely on it being used in the end).

Good luck with your modeling!

3D Rendering

See also 3D modeling.

In computer graphics 3D rendering is the process of computing images which represent a projected view of 3D objects through a virtual camera.

There are many methods and algorithms for doing so differing in many aspects such as computation complexity, implementation complexity, realism of the result, representation of the 3D data, limitations of viewing and so on. If you are just interested in the realtime 3D rendering used in gaymes nowadays, you are probably interested in GPU-accelerated 3D rasterization with APIs such as OpenGL and Vulkan.

LRS has a simple 3D rendering library called small3dlib.

Methods

As most existing 3D "frameworks" are harmful, a LRS programmer is likely to write his own 3D rendering system that suits his program best, therefore we should list some common methods of achieving 3D. Besides that, it's just pretty interesting to see what there is in the store.

A very important realization of a graphics programmer is that 3D rendering is to a great extent about faking (especially the mainstream realtime 3D) -- it is an endeavor that seeks to produce something that looks somehow familiar to HUMAN sight specifically and so even though the methods are mathematical, the endeavor is really an art in the end, not dissimilar to that of a magician who searches for "smoke and mirrors" hacks to produce illusions for the audience. Reality is infinitely complex, we use nothing else but approximations and neglecting that rely on assumptions about human sight such as "60 FPS looks like smooth movement to human eye", "infrared spectrum is invisible", "humans can't tell a mirror reflection is a bit off", "inner corners are usually darker than flat surfaces", "no shadow is completely black because light scatters in the atmosphere" etc. Really 3D graphics is nothing but searching for what looks good enough, and deciding this relies on a SUBJECTIVE judgement of a human (and sometimes every individual). In theory -- if we had infinitely powerful computers -- we would just program in a few lines of electromagnetic equations and run the precise simulation of light propagating in 3D environment to produce an absolutely realistic result, but though some methods try to come close to said approach, we simply won't ever have infinitely powerful computers. For this we have to resort to a bit more ugly approach of identifying specific notable real-life phenomena individually (for example caustics, Fresnel, mirror reflections, refractions, subsurface scattering, metallicity, noise, motion blur and myriads of others) and addressing each one individually with special treatment, many times correcting and masking our imperfections (e.g. applying antialiasing because we dared to use a simplified model of light sampling, applying texture filtering because we dared to only use finite amount of memory for our data, applying postprocessing etc.).

Rendering spectrum: The book Real-Time Rendering mentions that methods for 3D rendering can be seen as lying on a spectrum, one extreme of which is appearance reproduction and the other physics simulation. Methods closer to trying to imitate the appearance try to simply focus on imitating the look of an object on the monitor that the actual 3D object would have in real life, without being concerned with how that look arises in real life (i.e. closer to the "faking" approach mentioned above) -- these may e.g. use image data such as photographs; these methods may rely on lightfields, photo textures etc. The physics simulation methods try to replicate the behavior of light in real life -- their main goal is to solve the rendering equation, still only more or less approximately -- and so, through internally imitating the same processes, come to similar visual results that arise in real world: these methods rely on creating 3D geometry (e.g. that made of triangles or voxels), computing light reflections and global illumination. This is often easier to program but more computationally demanding. Most methods lie somewhere in between these two extremes: for example billboards and particle systems may use a texture to represent an object while at the same time using 3D quads (very simple 3D models) to correctly deform the textures by perspective and solve their visibility. The classic polygonal 3D models are also usually somewhere in between: the 3D geometry and shading are trying to simulate the physics, but e.g. a photo texture mapped on such 3D model is the opposite appearance-based approach (PBR further tries to shift the use of textures more towards the physics simulation end).

With this said, let's now take a look at possible classifications of 3D rendering methods. As seen, there are many ways:

• by order:
  • object order: The method iterates on objects and draws object by object, one after another. This results in pixels being drawn to "random" places on the screen and possibly already drawn pixels being overdrawn with new pixels (though this can be further reduced). Typically requires a frame buffer and double buffering, often also z-buffer (or sorting), i.e. requires a lot of memory. This method is also a bit ugly but typically also faster than the alternative, so it is prevailing nowadays.
  • image order: The method iterates on screen pixels, typically going pixel by pixel from left to right, top to bottom, deciding the color of each pixel independently. May be easier to program and require less memory (no frame buffer is needed, see e.g. frameless rendering), however though parallelism is applicable here (many pixels may potentially be independently computed in parallel, speeding up rendering), the algorithms used (e.g. path tracing) often have to expensively simulate light behavior and so performance is still an issue.
• by speed:
  • realtime: Able to render at interactive FPS, typically used in games etc.
  • offline: Spends a lot of time (even many minutes) on rendering each frame with the goal to produce output of extreme quality, typically used to render 3D movies etc.
• by relative limitation:
  • primitive/"pseudo3D"/2.5D/...: Older methods that produce 3D views but had great limitations e.g. in camera degrees of freedom or possible environment geometry that was usually limited to a "2D sector map" (see e.g. Doom).
  • full/"true" 3D: The "new" way of 3D rendering that allows freely rotating camera, arbitrary 3D geometry etc. Though this still has limitations (as any computer approximation of reality), many people just call this the "true" 3D.
• by approach (sides of above mentioned rendering spectrum):
  • appearance based: Focuses on achieving desired appearance by any means necessary, faking, "cheating", not trying to stay physically correct. This is typically faster.
  • physics simulation (see also physically based rendering): Focuses on simulating the underlying physics of reality with high correctness so that we also get a very realistic result.
• by main method/algorithm (see also the table below):
  • rasterization: Appearance based object order methods further based on a relatively simple algorithm capable of drawing (rasterizing) a simple geometric shape (such as a triangle) which we then use to draw the whole complex 3D scene (composed of great many of triangles).
  • ray casting/tracing: Physics simulation image order methods further based on tracing paths of light in a manner that's closer to reality.
  • ...
• by 3D data (vector vs raster classification applies here just as in 2D graphics):
  • triangle meshes (vector, and other boundary representations)
  • voxels (raster, and potentially other volumetric representations)
  • point clouds
  • heightmaps
  • implicit surfaces
  • smooth surfaces (e.g. NURBS)
  • 2D sectors (e.g. Doom's BSP "pseudo 3D" rendering)
  • ...
• by hardware:
  • software rendering: Rendering only with CPU. This is typically slower as a CPU mostly performs sequential computation, eliminating the possible parallelism optimization, however the approach is more KISS and portable.
  • GPU accelerated: Making use of specialized graphics rendering hardware (GPU) that typically uses heavy parallelism to immensely speed up rendering. While this is the mainstream, extremely fast way of rendering, it is also greatly bloated while often being an overkill that greatly complicates programming and makes programs less portable, less future proof etc.
• by realism of output:
  • photorealistic
  • stylized, flat shaded, wireframe, ...
  • ...
• hybrids: Methods may be combined and/or lie in between different extremes, for example we may see a rasterizer 3D renderer that uses ray tracing to add detail (shadows, reflections, ...) to the scene, we may see renderers that allow triangle meshes as well as voxels etc. { One nice hybrid looking engine is e.g. Chasm: The Rift. ~drummyfish }
• ...

Finally a table of some common 3D rendering methods follows, including the most simple, most advanced and some unconventional ones. Note that here we talk about methods and techniques rather than algorithms, i.e. general approaches that are often modified and combined into a specific rendering algorithm. For example the traditional triangle rasterization is sometimes combined with raytracing to add e.g. realistic reflections. The methods may also be further enriched with features such as texturing, antialiasing and so on. The table below should help you choose the base 3D rendering method for your specific program.

The methods may be tagged with the following:

• 2.5D: primitive 3D, often called pseudo 3D or fake 3D, having significant limitations e.g. in degrees of freedom of the camera
• off: slow method usually used for offline (non-realtime) rendering (even though they indeed may run in real time e.g. with the help of powerful GPUs)
• IO vs OO: image order (rendering by pixels) vs object order (rendering by objects)

TODO: Rescue On Fractalus!

TODO: find out how build engine/slab6 voxel rendering worked and possibly add it here (from http://advsys.net/ken/voxlap.htm seems to be based on raycasting)

TODO: VoxelQuest has some innovative voxel rendering, check it out (https://www.voxelquest.com/news/how-does-voxel-quest-work-now-august-2015-update)

3D Rendering Basics For Nubs

If you're a complete noob and are asking what the essence of 3D is or just how to render simple 3Dish pictures for your game without needing a PhD, here's the very basics. Yes, you can use some 3D engine such as Godot that has all the 3D rendering preprogrammed, but you'll surrender to bloat, you won't really know what's going on and your ability to tinker with the rendering or optimizing it will be basically zero... AND you'll miss on all the fun :) So here we just foreshadow some concepts you should start with if you want to program your own 3D rendering.

The absolute basic thing in 3D is probably perspective, or the concept which says that "things further away look smaller". This is basically the number one thing you need to know and with which you can make simple 3D pictures, even though there are many more effects and concepts that "make pictures look 3D" and which you can potentially study later (lighting, shadows, focus and blur, stereoscopy, parallax, visibility/obstruction etc.). { It's probably possible to make something akin "3D" even without perspective, just with orthographic projection, but that's just getting to details now. Let's just suppose we need perspective. ~drummyfish }

If you don't have rotating camera and other fancy things, perspective is actually mathematically very simple, you basically just divide the object's size by its distance from the viewer, i.e. its Z coordinate (you may divide by some multiple of Z coordinate, e.g. by 2 * Z to get different field of view) -- the further away it is, the bigger number its size gets divided by so the smaller it becomes. This "dividing by distance" ultimately applies to all distances, so in the end even the details on the object get scaled according to their individual distance, but as a first approximation you may just consider scaling objects as a whole. Just keep in mind you should only draw objects whose Z coordinate is above some threshold (usually called a near plane) so that you don't divide by 0! With this "dividing by distance" trick you can make an extremely simple "3Dish" renderer that just draws sprites on the screen and scales them according to the perspective rules (e.g. some space simulator where the sprites are balls representing planets). There is one more thing you'll need to handle: visibility, i.e. nearer objects have to cover the further away objects -- you can do this by simply sorting the objects by distance and drawing them back-to-front (painter's algorithm).

Here is some "simple" C code that demonstrates perspective and draws a basic animated wireframe cuboid as ASCII in terminal:

#include <stdio.h>

#define SCREEN_W 50       // ASCII screen width
#define SCREEN_H 22       // ASCII screen height
#define LINE_POINTS 64    // how many points for drawing a line
#define FOV 8             // affects "field of view"
#define FRAMES 30         // how many animation frames to draw

char screen[SCREEN_W * SCREEN_H];

void showScreen(void)
{
  for (int y = 0; y < SCREEN_H; ++y)
  {
    for (int x = 0; x < SCREEN_W; ++x)
      putchar(screen[y * SCREEN_W + x]);

    putchar('\n');
  }
}

void clearScreen(void)
{
  for (int i = 0; i < SCREEN_W * SCREEN_H; ++i)
    screen[i] = ' ';
}

// Draws point to 2D ASCII screen, [0,0] means center.
int drawPoint2D(int x, int y, char c) 
{
  x = SCREEN_W / 2 + x;
  y = SCREEN_H / 2 + y;

  if (x >= 0 && x < SCREEN_W && y >= 0 && y <= SCREEN_H)
    screen[y * SCREEN_W + x] = c;
}

// Divides coord. by distance taking "FOV" into account => perspective.
int perspective(int coord, int distance)
{
  return (FOV * coord) / distance;
}

void drawPoint3D(int x, int y, int z, char c)
{
  if (z <= 0)
    return; // at or beyond camera, don't draw

  drawPoint2D(perspective(x,z),perspective(y,z),c);
}

int interpolate(int a, int b, int n)
{
  return a + ((b - a) * n) / LINE_POINTS;
}

void drawLine3D(int x1, int y1, int z1, int x2, int y2, int z2, char c)
{
  for (int i = 0; i < LINE_POINTS; ++i) // draw a few points to form a line
    drawPoint3D(interpolate(x1,x2,i),interpolate(y1,y2,i),interpolate(z1,z2,i),c);
}

int main(void)
{
  int shiftX, shiftY, shiftZ;

  #define N 12  // side length
  #define C '*'

  // cuboid points:
  //      X                   Y            Z
  #define PA -2 * N + shiftX, N + shiftY,  N + shiftZ
  #define PB 2 * N + shiftX,  N + shiftY,  N + shiftZ
  #define PC 2 * N + shiftX,  N + shiftY,  2 * N + shiftZ
  #define PD -2 * N + shiftX, N + shiftY,  2 * N + shiftZ
  #define PE -2 * N + shiftX, -N + shiftY, N + shiftZ
  #define PF 2 * N + shiftX,  -N + shiftY, N + shiftZ
  #define PG 2 * N + shiftX,  -N + shiftY, 2 * N + shiftZ
  #define PH -2 * N + shiftX, -N + shiftY, 2 * N + shiftZ

  for (int i = 0; i < FRAMES; ++i) // render animation
  {
    clearScreen();

    shiftX = -N + (i * 4 * N) / FRAMES; // animate
    shiftY = -N / 3 + (i * N) / FRAMES;
    shiftZ = 0; 

    // bottom:
    drawLine3D(PA,PB,C); drawLine3D(PB,PC,C); drawLine3D(PC,PD,C); drawLine3D(PD,PA,C);

    // top:
    drawLine3D(PE,PF,C); drawLine3D(PF,PG,C); drawLine3D(PG,PH,C); drawLine3D(PH,PE,C);

    // sides:
    drawLine3D(PA,PE,C); drawLine3D(PB,PF,C); drawLine3D(PC,PG,C); drawLine3D(PD,PH,C);

    drawPoint3D(PA,'A'); drawPoint3D(PB,'B'); // corners
    drawPoint3D(PC,'C'); drawPoint3D(PD,'D');
    drawPoint3D(PE,'E'); drawPoint3D(PF,'F');
    drawPoint3D(PG,'G'); drawPoint3D(PH,'H');

    showScreen();

    puts("press key to animate");
    getchar();
  }

  return 0;
}

One frame of the animation should look like this:

                 E*******************************F
                 * *                       ***   *
                 *  **                 ***       *
                 *   H***************G*          *
                 *   *               *           *
                 *   *               *           *
                 *   *               *           *
                 *   *               *           *
                 *   *               *           *
                 *   *               *           *
                 *   D***************C           *
                 *  **                ***        *
                 *  *                    *       *
                 * *                       **    *
                 ***                         * * *
                 A*******************************B

press key to animate

PRO TIP: It also help if you learn a bit about photography because 3D usually tries to simulate cameras and 3D programmers adopt many terms and concepts from photography. At least learn the very basics such as focal length, pinhole camera, the "exposure triangle" (shutter speed, aperture, ISO) etc. You should know how focal length is related to FOV, what the "f number" means, how to use exposure settings to increase or decrease things like motion blur and depth of field, what HDR means etc.

Mainstream Realtime 3D

You may have come here just to learn about the typical realtime 3D rendering used in today's games because aside from research and niche areas this kind of 3D is what we normally deal with in practice. This is what this section is about.

These days "game 3D" means a GPU accelerated 3D rasterization done with rendering APIs such as OpenGL, Vulkan, Direct3D or Metal (the last two being proprietary and therefore shit) and higher level engines above them, e.g. Godot, OpenSceneGraph etc. The methods seem to be evolving to some kind of rasterization/pathtracing hybrid, but rasterization is still the basis.

This mainstream rendering uses an object order approach (it blits 3D objects onto the screen rather than determining each pixel's color separately) and works on the principle of triangle rasterization, i.e. 3D models are composed of triangles (or higher polygons which are however eventually broken down into triangles) and these triangles are projected onto the screen according to the position of the virtual camera and laws of perspective. Projecting the triangles means finding the 2D screen coordinates of each of the triangle's three vertices -- once we have thee coordinates, we draw (rasterize) the triangle to the screen just as a "normal" 2D triangle (well, with some asterisks).

Additionally things such as z-buffering (for determining correct overlap of triangles) and double buffering are used, which makes this approach very memory (RAM/VRAM) expensive -- of course mainstream computers have more than enough memory but smaller computers (e.g. embedded) may suffer and be unable to handle this kind of rendering. Thankfully it is possible to adapt and imitate this kind of rendering even on "small" computers -- even those that don't have a GPU, i.e. with pure software rendering. For this we e.g. replace z-buffering with painter's algorithm (triangle sorting), drop features like perspective correction, MIP mapping etc. (of course quality of the output will go down).

Also additionally there's a lot of bloat added in such as complex screen space shaders, pathtracing (popularly known as raytracing), megatexturing, shadow rendering, postprocessing, compute shaders etc. This may make it difficult to get into "modern" 3D rendering. Remember to keep it simple.

On PCs the whole rendering process is hardware-accelerated with a GPU (graphics card). GPU is a special hardware capable of performing many operations in parallel (as opposed to a CPU which mostly computes sequentially with low level of parallelism) -- this is ideal for graphics because we can for example perform mapping and drawing of many triangles at once, greatly increasing the speed of rendering (FPS). However this hugely increases the complexity of the whole rendering system, we have to have a special API and drivers for communication with the GPU and we have to upload data (3D models, textures, ...) to the GPU before we want to render them. Debugging gets a lot more difficult. So again, this is bloat, consider avoiding GPUs.

GPUs nowadays are no longer just focusing on graphics, but are kind of a general device that can be used for more than just 3D rendering (e.g. crypto mining, training AI etc.) and can no longer even perform 3D rendering completely by themselves -- for this they have to be programmed. I.e. if we want to use a GPU for rendering, not only do we need a GPU but also some extra code. This code is provided by "systems" such as OpenGL or Vulkan which consist of an API (an interface we use from a programming language) and the underlying implementation in a form of a driver (e.g. Mesa3D). Any such rendering system has its own architecture and details of how it works, so we have to study it a bit if we want to use it.

The important part of a system such as OpenGL is its rendering pipeline. Pipeline is the "path" through which data go through the rendering process. Each rendering system and even potentially each of its version may have a slightly different pipeline (but generally all mainstream pipelines somehow achieve rasterizing triangles, the difference is in details of how they achieve it). The pipeline consists of stages that follow one after another (e.g. the mentioned mapping of vertices and drawing of triangles constitute separate stages). A very important fact is that some (not all) of these stages are programmable with so called shaders. A shader is a program written in a special language (e.g. GLSL for OpenGL) running on the GPU that processes the data in some stage of the pipeline (therefore we distinguish different types of shaders based on at which part of the pipeline they reside). In early GPUs stages were not programmable but they became so as to give a greater flexibility -- shaders allow us to implement all kinds of effects that would otherwise be impossible.

Let's see what a typical pipeline might look like, similarly to something we might see e.g. in OpenGL. We normally simulate such a pipeline also in software renderers. Note that the details such as the coordinate system handedness and presence, order, naming or programmability of different stages will differ in any particular pipeline, this is just one possible scenario:

1. Vertex data (e.g. 3D model space coordinates of triangle vertices of a 3D model) are taken from a vertex buffer (a GPU memory to which the data have been uploaded).
2. Stage: vertex shader: Each vertex is processed with a vertex shader, i.e. one vertex goes into the shader and one vertex (processed) goes out. Here the shader typically maps the vertex 3D coordinates to the screen 2D coordinates (or normalized device coordinates) by:

• multiplying the vertex by a model matrix (transforms from model space to world space, i.e. applies the model move/rotate/scale operations)
• multiplying by view matrix (transforms from world space to camera space, i.e. takes into account camera position and rotation)
• multiplying by projection matrix (applies perspective, transforms from camera space to screen space in homogeneous coordinates)

3. Possible optional stages that follow are tessellation and geometry processing (tessellation shaders and geometry shader). These offer possibility of advanced vertex processing (e.g. generation of extra vertices which vertex shaders are unable to do).
4. Stage: vertex post processing: Usually not programmable (no shaders here). Here the GPU does things such as clipping (handling vertices outside the screen space), primitive assembly and perspective divide (transforming from [homogeneous coordinates](homogeneous coordinates.md) to traditional cartesian coordinates).
5. Stage: rasterization: Usually not programmable, the GPU here turns triangles into actual pixels (or fragments), possibly applying backface culling, perspective correction and things like stencil test and depth test (even though if fragment shaders are allowed to modify depth, this may be postpones to later).
6. Stage: pixel/fragment processing: Each pixel (fragment) produced by rasterization is processed here by a pixel/fragment shader. The shader is passed the pixel/fragment along with its coordinates, depth and possibly other attributes, and outputs a processed pixel/fragment with a specific color. Typically here we perform shading and texturing (pixel/fragment shaders can access texture data which are again stored in texture buffers on the GPU).
7. Now the pixels are written to the output buffer which will be shown on screen. This can potentially be preceded by other operations such as depth tests, as mentioned above.

TODO: example of specific data going through the pipeline

See Also

• 3d modeling
• software rendering
• autostereogram

42

"HAHAHAHAHAHAHAHAHAHHHHAAA BAZINGA" --Sheldon fan

42 is an even integer with prime factorization of 2 * 3 * 7. This number was made kind of famous (and later overused in pop culture to the point of completely destroying the joke) by Douglas Adams' book The Hitchhiker's Guide to the Galaxy in which it appears as the answer to the ultimate question of life, the Universe and everything (the point of the joke was that this number was the ultimate answer computed by a giant supercomputer over millions of years, but it was ultimately useless as no one knew the question to which this number was the answer).

If you make a 42 reference in front of a TBBT fan, he will shit himself.

See Also

• bazinga
• thrembo
• foo (similarly overplayed "joke")
• 69

4chan

{ haha https://lolwut.info/comp/4chan/4chan-g.html ~drummyfish }

4chan (https://4chan.org/, also 4cuck) is the most famous image board, a website causing controversies by its low censorship and a place of great fun, trolling, toxicity and memes. It was started in 2003 by moot (Christopher Poole, born 1988). As most image boards, 4chan has a nice, oldschool minimalist look, even though it contains shitty captchas for posting and the site's code is proprietary. The site tolerates a great amount of free speech up to the point of being regularly labeled "right-wing extremist site", though it actually censors a lot of stuff and bans for stupid reasons such as harmless pedo jokes are very common (speaking from experience) -- 4chan global rules for example PROHIBIT CRITICISING 4chan (LMAO, rule no. 8), doxxing and call for raids. Being a "rightist paradise" it is commonly seen as a rival to reddit, aka the pseudoleftist paradise -- both forums hate each other to death. The discussion style is pretty nice, there are many nice stories and memes (e.g. the famous greentexts) coming from 4chan but it can also be a hugely depressing place just due to the shear number of retards with incorrect opinions.

Just as reddit consists of subcommunities known as subreddits, 4chan consists of different boards (just as other image boards), each with given discussion topic and rules. The most (in)famous boards are likely politically incorrect AKA /pol/, where most of the american school shooters hang around, and random AKA /b/, the most active board, which is just a shitton of meme shitposting, porn, toxicity, fun, trolling and retardedness.

For us the most important part of 4chan is the technology board known as /g/ (for technoloGEE). Browsing /g/ can bring all kinds of emotion, it's a place of relative freedom and somewhat beautiful chaos where all people from absolute retards to geniuses argue about important and unimportant things, brands, tech news and memes, and constantly advise each other to kill themselves. Sometimes the place is pretty toxic and not good for mental health, actually it is more of a rule than an exception.

UPDATE: As of 2022 /g/ became literally unreadable, ABANDON SHIP. The board became flooded with capitalists, cryptofascists, proprietary shills, productivity freaks and other uber retards, it's really not worth reading anymore. You can still read good old threads on archives such as https://desuarchive.org/g/page/280004/. ALSO 2024 update: 4chan is also completely unusable now because it's cuckflared and posting requires unsolvable captchas (they are actually unsolvable, you must have PAID account to bypass it, so to post you now de facto have to pay). Lurking on some other more relaxed boards such as /x and /vr may still be cool, but in general accept that the site is dead, find something else.

Despite dwelling slightly underground -- maybe better said being isolated from the normie "safespace" censornet -- 4chan has really been very notably significant for the whole Internet culture, long books could be written about its history, culture, unique, intricate social mechanism of its ways of communication and impact on the rest of the cyberspace; the "4chan experience" is one of the things that can't faithfully be described by words, it has to be lived. Just like reddit mixed some interesting concepts into a unique, yet more powerful combination that's more than a sum of its ingredients, so did 4chan -- yes, other boards are to be credited for this too, but 4chan is the flagship, the center of it all. Especially important seems to be the anonymity aspect, you never know who you are talking to, it's never clear if someone is trolling, serious, shilling, extremely dumb or something in between. There is no karma, no handles, no profile pictures, no upvotes (at best there are numbers of replies), no post history, no account age, you have to rely on judging people by unusual attributes, for example by the style of their talk, their knowledge of the lore and latest memes, by how they format their posts (e.g. the infamously hated empty lines), what images they attach (and what they're file names are), as these are the only clues. A thread on 4chan isn't something with a clear goal, you don't know if someone is asking a question because he wants a genuine answer or because he's just bored and wants to see funny answers, or if he's posting a bait and is trying to trigger others, so each discussion is a bit of a game, you're trying to guess what's going on. A famous post, for example, had itself heard that the poster despises translations of books and always reads any book in its original language despite not understanding a word of it, and that he already read works such as Don Quixote and Les Miserables in their respective languages without knowing what they were about -- this stupidity combined with extreme determination and dedication captures part of what makes 4chan what it is. Also everything is temporary, every thread and image is deleted in a short time, which is an important factor too, everything is constantly in motion, people have to react quickly, there is no turning back, reactions are quick and genuine, if you miss something it's gone. Also the image memes themselves show how art (who cares if low) evolves if completely unrestrained, anyone can try to spawn a new meme or download anyone else's posted meme, repost it or modify it, copyright mostly de facto won't apply as the authors are unknown; bad works are filtered out while good ones remain simply by making others save them and keep reposting them, it's art without authors, separated from the people, evolving completely on its own, purely by its intrinsic attributes, unconstrained evolution at work right before our eyes -- this is a seriously scientifically interesting stuff.

Alternatives to 4chan: just check out other image boards like 8kun, anon.cafe, leftychan.net, wizardchan, soyjak.party, BAI, 1436chan (gopher) etc. Also check out other types of forums than image boards such as saidit.net, voat or encyclopedia dramatica forums. You won't have much success searching for these using Goolag.

{ Also check out https://wiki.soyjaks.party, it's a great place, CC0, tons of 4chan lore, kinda like encyclopedia dramatica 2. ~drummyfish }

See Also

• Encyclopedia Dramatica
• reddit
• 8kun
• bienvenido a internet
• something awful
• rare Pepe

Aaron Swartz

"I think all censorship should be deplored." --Aaron Swartz

Aaron Swartz (1986 - 2013) was an American jewish prodigy that did a lot of activism and played a big role in creation of Reddit (back then a big platform for free speech, nowadays hugely censored), RSS, Creative Commons, Markdown and other quite important things. His life story is quite sad as he killed himself by hanging at a young age (there are some conspiracy theories around it), people see this loss as even more tragic because he was so talented and could have done many great things. But don't be mistaken, he was also an American and an "entrepreneur", so a capitalist at least to some degree; do not follow people, appreciate their art and their ideas.

Abstraction

Abstraction is an important concept in programming, mathematics and other fields of science, philosophy and art, which in simple words can be described as "viewing an issue from a distance", thinking in higher-level concepts, i.e. paying less attention to fine detail so that one can see the bigger picture. In programming for example we distinguish programming languages of high and low level of abstraction, depending on how close they are "to the hardware" (e.g. assembly being low level, JavaScript being high level); in art high abstraction means portraying and capturing things such as ideas, feelings and emotions with shapes that may seem "distant", not resembling anything concrete or familiar. We usually talk about different levels of abstraction, depending on the "distance" we take in vieweing the issue at hand -- this concept may very well be demonstrated on sciences: particle physics researches the world at the lowest level of abstraction, in extreme close-up, for example by examining individual atoms that make up our brains, while biology resides at a higher level of abstraction, viewing the brain at the level of individual cells, and finally psychology shows a very high level of abstraction because it looks at the brain from great distance and just studies its behavior.

In mainstream programming education it is generally taught to "abstract as much as possible" because that's aligned with the capitalist way of technology -- high abstraction is easy to handle for incompetent programming monkeys, it helps preventing them from making damage by employing billions of safety mechanisms, it also perpetuates the cult of never stopping layering of the abstraction sandwich, creating bloat, hype, bullshit jobs, it makes computers slower, constantly outdated and so drives software consumerism. As with everything in capitalism, new abstractions are products hyped on grounds of immediate benefit: creating more comfort, being something new and "modern", increasing "productivity", lowering "barriers of entry" so that ANYONE CAN NOW BE A PROGRAMMER without even knowing anything about computers (try to imagine this e.g. in the field of medicine) etc. -- of course, long term negative effects are completely ignored. This is extremely wrong. It is basically why technology has been on such a huge downfall in the latest decades. Opposing this, LRS advocates to employ only as little abstraction as needed, so as to support minimalism. Too much abstraction is bad. For example a widely used general purpose programming language should basically only have as much abstraction as to allow portability, it should definitely NOT succumb high abstraction such as object obsessed programming.

In a more detailed view abstraction is not one-dimensional, we may abstract in different directions ("look at the issue from different angles"); for example functional, logic and object paradigms are different ways of programming languages abstracting from the low level, each one in different way. So the matter of abstracting is further complicated by trying to choose the right abstraction -- one kind of abstraction may work well for certain kinds of problems (i.e. solving these problems will become simple when applying this abstraction) but badly for other kinds of problems. The art of choosing right abstraction (model) is important e.g. in designing computer simulations -- if we want so simulate e.g. human society, do we simulate individual people in it or just societies as whole entities? Do we simulate wars as a simple dice roll or do we let individual soldiers fight their own battles? Do we represent roads as actual surfaces on top of which cars move according to laws of physics, or do we simplify to something like mathematical graph connecting cities with mere abstract lines, or something in between like a cellular automaton maybe? Do we consider beings living on a round planet, with possibilities like meteor impacts and space flights, or do we simply consider people living on a flat 2D sheet of paper? Similar though has come to designing games (another kind of simulation).

Let's take a look at a possible division of a computer to different levels of abstraction, from lowest to highest (keep in mind it's also possible to define the individual levels differently):

• physics: Computer is a collection of atoms and subatomic particles such as electrons, operating with terms such as energy, charge, spin or quantum effects.
• electronic circuit: Computer is an analog circuit in which electricity flows through wires and electronic components, operating with terms such as voltage, current, transistor, resistor or electronic interference.
• logic circuit: Computer is a binary digital circuit; this is abstracting electricity away, now we are only considering two possible values carried by the wires: 1s and 0s. Operating with terms such as logic gate, logic function, multiplexer or sequential circuit.
• machine code/assembly: Computer is a machine with a specific instruction architecture, executing an algorithm encoded as simple binary instructions, such as "add two numbers" or "write a number to memory", in a specific format that's different for different types of computers. Operating with terms such as CPU cycle, opcode, register, memory or interrupt.
• low level portable language: Computer is a machine capable of performing algorithms written in a structured language resembling human language and it's a machine that's essentially the same as other computers, even of different types, i.e. all computers can understand the same language (programs are portable), typically e.g. C. Operating with terms such as structured data type, procedure, signed/unsigned type, memory management etc.
• high level language: Computer is a machine capable of performing algorithms while handling many things (such as memory allocation or ensuring safety) automatically and dynamically (on-the-go) and understanding more complex and abstract descriptions of problems, allowing for very fast and comfortable programming in languages like Python or JavaScript. Operating with terms such as objects, dictionaries, pure functions and polymorphism.
• very high level, artificial intelligence: Computer is a machine capable of simulating human thinking and therefore able to lead a conversation with human, it can perform commands given in natural language and even reason and create on its own. Operating with terms such as training, data sets and ethics.

See Also

• https://unixsheikh.com/articles/we-have-used-too-many-levels-of-abstractions-and-now-the-future-looks-bleak.html

Acronym

Acronym is an abbreviation of a multiple word term by usually appending the starting letters of each word to form a new word.

Here is a list of some acronyms:

• AA (anti aliasing)
• AC (alternating current, air conditioning)
• AD (anno domini)
• ACID (atomicity consistency isolation durability)
• ACK (acknowledgement)
• ADSL (asymmetric digital subscriber line)
• AF (as fuck)
• AFAIK (as far as I know)
• AJAX (asynchronous JavaScript and XML)
• AFK (away from keyboard)
• ALU (arithmetic logic unit)
• AM (amplitude modulation)
• ANCAP (anarcho capitalist)
• ANPAC (anarcho pacifist)
• ANSI (american national standards institute)
• AO (ambient occlusion)
• API (application programming interface)
• ARM (advanced RISC machines)
• ARPANET (advanced research projects agency network)
• ASAP (as soon as possible)
• ASCII (American standard code for information interchange)
• ASM (assembly)
• ATM (at the moment, automated teller machine)
• B (byte, bit)
• B4 (before)
• BAI (bienvenido a internet)
• BASH (bourne again shell)
• BASIC (beginner all purpose symbolic instruction code)
• BBC (big black cock)
• BBS (bulletin board system)
• BC (bytecode, before Christ)
• BCD (binary coded decimal)
• BDFL (benevolent dictator for life)
• BDSM (bondage domination sadism masochism)
• BF (brainfuck)
• BG (background, bad game)
• BGR (blue green red)
• BIOS (basic input/output system)
• BJ (blow job)
• BJT (bipolar junction transistor)
• BS (bullshit)
• BSD (Berkeley software distribution)
• BTFO (blown the fuck out)
• CAD (computer aided design)
• CAPTCHA (completely automated public Turing test to tell computers and humans apart)
• CC (creative commons, C compiler)
• CC0 (creative commons zero)
• CD (compact disc, change directory)
• CEO (chief executive officer)
• CGI (computer generated imagery)
• CISC (complex instruction set computer)
• CLI (command line interface)
• CMOS (complementary metal oxide semiconductor)
• CMS (content management system)
• CMYK (cyan magenta yellow key)
• COMPSCI (computer science)
• CP (child porn, copy)
• CPU (central processing unit)
• CRC (cyclic redundancy check)
• CRT (cathode ray tube)
• CSG (constructive solid geometry)
• CSS (cascading style sheet)
• CSV (comma separated values)
• DAC (digital analog converter)
• DB (database)
• DC (direct current)
• DDOS (distributed denial of service)
• DDR (double data rate)
• DE (desktop environment)
• DHCP (dynamic host configuration protocol)
• DL (download)
• DMA (direct memory access)
• DMCA (digital millennium copyright act)
• DND (dungeons & dragons, do not disturb)
• DNS (domain name system)
• DOM (document object model)
• DOS (disk operating system, denial of service)
• DOTADIW (do one thing and do it well)
• DPI (dots per inch)
• DRAM (dynamic RAM)
• DRM (digital restrictions management)
• DRY (don't repeat yourself)
• DVD (digital versatile disc)
• ED (Enyclopedia Dramatica)
• EEPROM (electronically erasable programmable ROM)
• ELF (executable and linkable format)
• EMCAS (editor macros)
• ENIAC (electronic numerical integrator and computer)
• EOF (end of file)
• EOL (end of line, end of life)
• ERP (erotic role play)
• ESR (Erik Steven Raymond)
• EULA (end user license agreement)
• FAQ (frequently asked questions)
• FE (frontend)
• FET (field effect transistor)
• FFS (for fuck's sake)
• FIFO (first in first out)
• FLAC (free lossless audio codec)
• FLOSS (free libre open source software)
• FM (frequency modulation)
• FML (fuck my life)
• FORTRAN (formula translation)
• FOSH (free and open source hardware)
• FOSS (free and open source software)
• FSF (free software foundation)
• FP (floating point)
• FPGA (field programmable gate array)
• FPS (frames per second, first "person" shooter)
• FQA (frequently questioned answers)
• FS (file system)
• FTL (faster than light)
• FTP (file transfer protocol)
• FU (fuck you)
• FXAA (full screen anti aliasing)
• FYI (for your information)
• GB (gigabyte/gigabit, GameBoy)
• GBPS (GB per second)
• GCC (GNU compiler collection)
• GDB (GNU debugger)
• GI (global illumination)
• GIB (gibibyte)
• GIF (graphics interchange format)
• GIGO (garbage in garbage out)
• GIMP (GNU image manipulation program)
• GLUT (OpenGL utility toolkit)
• GNAA (Gay Nigger Association of America)
• GNOME (GNU network object model environment)
• GNG (GNG's Not GNU)
• GNU (GNU's Not Unix)
• GOAT (greatest of all time)
• GPG (GNU privacy guard)
• GPGPU (general purpose GPU)
• GPL (GNU General Public License)
• GPLv2 (GPL version 2)
• GPLv3 (GPL version 3)
• GPS (global positioning system)
• GPU (graphics processing unit)
• GRUB (grand unified boot loader)
• GSM (global system for mobile communication)
• GTK+ (GIMP toolking)
• GUI (graphical user interface)
• H8 (hate)
• HD (high definition)
• HDD (hard disc drive)
• HDMI (HD multimedia interface)
• HW (hardware)
• HTML (hypertext markup language)
• HTTP (hypertext transfer protocol)
• HTTPS (HTTP secure)
• HURD (hird of unix replacing demons)
• HQ (high quality)
• HZ (hertz)
• IANA (internet assigned number authority)
• IANAL (I am not a lawyer)
• ICMP (internet control message protocol)
• IDC (I don't care)
• IDE (integrated development environment)
• IEEE (institute for electrical and electronic
• IM (instant messaging)
• IMAP (internet message access protocol)
• IMHO (in my honest opinion)
• IMO (in my opinion)
• INB4 (in before)
• IO (input/output)
• IOT (internet of things)
• IPS (instructions per second)
• IP (internet protocol, intellectual property)
• IPV4 (IP version 4)
• IPV6 (IP version 6)
• IRC (internet relay chat)
• IRL (in real life)
• ISA (instruction set architecture)
• ISO (international organization for standardization)
• ISP (internet service provider)
• ISS (international space station)
• IS (information system)
• IT (information technology)
• J2ME (java 2 micro edition)
• JB (jailbait)
• JDK (java development kit)
• JIT (just in time)
• JK (just kidding)
• JPEG/JPG (joint photographic expert group)
• JS (JavaScript)
• JSON (JavaScript object notation)
• K&R (Kernighan and Ritchie)
• KB (kilobyte/kilobit)
• KBPS (KB per second)
• KDE (K desktop environment)
• KEK (a meme version of LOL coming from World Of Warcraft)
• KHZ (kilohertz)
• KIB (kibibyte)
• KILL (keep it Linux loser)
• KISS (keep it simple stupid)
• KISP (keep it simple perfect)
• KLOC (kilo LOC)
• KKK (ku klux klan)
• KYS (kill yourself)
• LAMP (linux apache mysql php)
• LARP (live action role play)
• LAN (local area network)
• LCD (liquid crystal display)
• LED (light emitting diode)
• LER (light emitting resistor)
• LGBT (lesbian gay bisexual trans)
• LGBTQ (lesbian gay bisexual trans queer)
• LGPL (lesser GPL)
• LIFO (last in first out)
• LISP (list processing)
• LMAO (laughing my ass off)
• LOC (lines of code)
• LOL (laughing out loud)
• LQ (low quality)
• LRS (less retarded software/society)
• LSB (least significant bit)
• LUT (lookup table)
• MBR (master boot record)
• MHZ (megahertz)
• MIB (mebibyte)
• MIME (multipurpose internet mail extension)
• MIP (multum in parvo)
• MIPS (millions of instructions per second)
• MBPS (MB per second)
• MCU (microcontroller unit)
• MD (markdown)
• MFW (my face when)
• MMO (massively multiplayer online)
• MMX (multimedia extension)
• MMORPG (MMO RPG)
• MOSFET (metal oxide semiconductor field effect transistor)
• MOTD (message of the day)
• MPEG (motion pictures experts group)
• MR (merge request)
• MS/M$ (Micro$oft)
• MSB (most significant bit)
• MSC (master of science)
• MSG (message)
• MUD (multi user dungeon)
• NAN (not a number)
• NASA (national aeronautic and space administration)
• NAT (network address translation)
• NC (non commercial)
• NEET (not in education, employment or training)
• NFT (non-fungible token)
• NGL (not gonna lie)
• NOP (no operation)
• NP (nondeterministic polynomial)
• NTFS (NT file system)
• OEM (original equipment manufacturers)
• OGL (OpenGL)
• OMG (oh my god)
• OO (object oriented, object obsessed, object obfuscated)
• OOP (object oriented/obsessed programming)
• OS (operating system, open source)
• OSS (open source software)
• OSI (open source initiative)
• P2P (peer to peer)
• PB (petabyte, petabit, personal best)
• PBR (physically based rendering)
• PC (personal computer, political correctness)
• PD (public domain)
• PDF (portable document format)
• PCM (pulse code modulation)
• PGP (pretty good privacy)
• PHD (doctor of philosophy)
• PID (process ID)
• PIN (personal identification number)
• PNG (portable network graphics)
• POP3 (post office protocol version 3)
• POSIX (portable operating system interface)
• PPC (power PC)
• PR (pull request)
• PS (Photoshop, Postscript, PlayStation)
• PS2 (personal system 2)
• PTHC (preteen hardcore)
• QOS (quality of service)
• RAID (redundant array of inexpensive discs)
• RAM (random access memory)
• RC (release candidate)
• RCL (raycastlib)
• REGEX (regular expression)
• RFC (request for comments)
• RGB (red green blue)
• RGBA (red green blue alpha)
• RISC (reduced instruction set computer)
• RIP (rest in piece)
• RLE (run length encoding)
• RMS (Richard Matthew Stallman)
• RN (right now)
• ROFL (rolling on floor laughing)
• ROM (read-only memory)
• RPG (role playing game)
• RPI (Raspberry Pi)
• RT (real time)
• RTFM (read the fucking manual)
• RTOS (real time operating system)
• S3L (small3dlib)
• SAAS (software as a service)
• SAASS (service as a software substitute)
• SAF (smallabstractfish)
• SBC (single board computer)
• SCL (smallchesslib)
• SD (standard definition, secure digital)
• SDF (signed distance function)
• SDK (software development kit)
• SDL (simple directmedia layer)
• SED (smoke emitting diode)
• SEO (search engine optimization)
• SFX (sound effects)
• SGML (standard generalized markup language)
• SHA (secure hash algorithm)
• SIG (special interest group)
• SIM (subscriber identity module)
• SIMD (single instruction multiple data)
• SLOC (source lines of code)
• SMS (short message service)
• SMTP (simple mail transfer protocol)
• SNTP (simple network time protocol)
• SOC (system on a chip)
• SQL (structured query language)
• SRAM (static RAM)
• SSAO (screen space ambient occlusion)
• SSD (solid state drive)
• SSH (secure shell)
• SSL (secure socket layer)
• STFU (shut the fuck up)
• SVG (scalable vector graphics)
• SW (software)
• TAS (tool assisted speedrun)
• TB (terabyte, terabit)
• TCC (tiny C compiler)
• TCP (transmission control protocol)
• TFT (thin filter transistor)
• TFW (that face when)
• TLA (three letter acronym)
• TM (trademark, Turing machine)
• TOS (terms of service)
• TTY (teletype)
• TUI (text user interface)
• UBI (universal basic income)
• UDP (user datagram protocol)
• UI (user interface)
• UML (unified modeling language)
• URI (uniform resource identifier)
• URL (uniform resource locator)
• USA (united states of america)
• USB (universal serial bus)
• UTC (coordinated universal time)
• UTF (unicode transformation format)
• UX (user experience)
• VCS (version control system)
• VOD (video on demand)
• VHS (video home system)
• VIM (vi improved)
• VFX (visual effects)
• VLAN (virtual LAN)
• VLIW (very long instruction word)
• VM (virtual machine)
• VPN (virtual private network)
• VPS (virtual private server)
• VRAM (video RAM)
• W3C (world wide web consortium)
• WAN (wide area network)
• WAP (wireless application protocol)
• WIFI (wireless fidelity)
• WOW (World Of Warcraft)
• WPA (WIFI protected access)
• WTF (what the fuck)
• WTFPL (do what the fuck you want to public license)
• WYSIWYG (what you see is what you get)
• WM (window manager)
• WWW (world wide web)
• XAML (extensible application markup language)
• XHTML (extensible HTML)
• XML (extensible markup language)
• YOLO (you only live once)
• ZOMG (when you want to write OMG but accidentally also hit Z)

See Also

• LRS dictionary

Artificial Intelligence

Artificial intelligence (AI) is an area of computer science whose effort lies in making computers simulate thinking of humans and possibly other biologically living beings. This may include making computers play games such as chess, compose music, paint pictures, understand and processing audio, images and text on high level of abstraction (e.g. translation between natural languages), making predictions about complex systems such as stock market or weather or even exhibit a general human-like behavior. Even though today's focus in AI is on machine learning and especially neural networks, there are many other usable approaches and models such as "hand crafted" state tree searching algorithms that can simulate and even outperform the behavior of humans in certain specialized areas.

There's a concern that's still a matter of discussion about the dangers of developing a powerful AI, as that could possibly lead to a technological singularity in which a super intelligent AI might take control over the whole world without humans being able to seize the control back. Even though it's still likely a far future and many people say the danger is not real, the question seems to be about when rather than if.

By about 2020, "AI" has become a capitalist buzzword. They try to put machine learning into everything just for that AI label -- and of course, for a bloat monopoly.

By 2023 neural network AI has become extremely advanced in processing visual, textual and audio information and is rapidly marching on. Networks such as stable diffusion are now able to generate images (or modify existing ones) with results mostly indistinguishable from real photos just from a short plain language textual description. Text to video AI is emerging and already giving nice results. AI is able to write computer programs from plain language text description. Chatbots, especially the proprietary chatGPT, are scarily human-like and can already carry on conversation mostly indistinguishable from real human conversation while showing extraordinary knowledge and intelligence -- the chatbot can for example correctly reason about advanced mathematical concepts on a level much higher above average human. AI has become mainstream and is everywhere, normies are downloading "AI apps" on their phones that do funny stuff with their images while spying on them. In games such as chess or even strategy video games neural AI has already been for years far surpassing the best of humans by miles.

See Also

• artificial life

Algorithm

Algorithm (from the name of Persian mathematician Muhammad ibn Musa al-Khwarizmi) is an exact step-by-step description of how to solve some type of a problem. Algorithms are basically what programming is all about: we tell computers, in very exact ways (with programming languages), how to solve problems -- we write algorithms. But algorithms don't have to be just computer programs, they are simply exact instruction for solving problems. Although maybe not as obvious, mathematics is also a lot about creating algorithms because it strives to give us exact instructions for solving problems -- a mathematical formula usually tells us what we have to do to compute something, so in a way it is an algorithm too.

Cooking recipes are commonly given as an example of a non-computer algorithm, though they rarely contain branching ("if condition holds then do...") and loops ("while a condition holds do ..."), the key features of algorithms. The so called wall-follower is a simple algorithm to get out of any maze which doesn't have any disconnected walls: you just pick either a left-hand or right-hand wall and then keep following it. You may write a crazy algorithm basically for any kind of problem, e.g. for how to clean a room or how to get a girl to bed, but it has to be precise so that anyone can execute the algorithm just by blindly following the steps; if there is any ambiguity, it is not considered an algorithm; a vague, imprecise "hint" on how to find a solution (e.g. "the airport is somewhere in this general direction.") we rather call a heuristic. Heuristics are useful too and they may be utilized by an algorithm, e.g. to find a precise solution faster, but from programmer's point of view algorithms, the PRECISE ways of finding solutions, are the basics of everything.

Interesting fact: contrary to intuition there are problems that are mathematically proven to be unsolvable by any algorithm, see undecidability, but for most practically encountered problems we can write an algorithm (though for some problems even our best algorithms can be unusably slow).

Algorithms are mostly (possibly not always, depending on exact definition of the term) written as a series of steps (or "instructions"); these steps may be specific actions (such as adding two numbers or drawing a pixel to the screen) or conditional jumps to other steps ("if condition X holds then jump to step N, otherwise continue"). At the lowest level (machine code, assembly) computers cannot do anything more complex than that: execute simple instructions (expressed as 1s and 0s) and perform conditional jumps -- in this computers are quite dumb (their strength comes from being able to execute many instruction with extreme speed). These jumps can be used to create branches (in programming known as if-then-else) and loops. Branches and loops are together known as control structures -- they don't express a direct action but control which steps in the algorithm will follow. All in all, any algorithm can be built just using these three basic constructs:

• sequence: A series of steps, one after another. E.g. "write prompt, read number from input, multiply it by two, store it to memory".
• selection (branches, if-then-else): Two branches (blocks of instructions) preceded by a condition; the first branch is executed only if the condition holds, the second ("else") branch is executed only if the condition doesn't hold (e.g. "If user password is correct, log the user in, otherwise print out an error."). The second branch is optional (it may remain empty).
• iteration (loops, repetition): Sequence of steps that's repeated as long as certain condition holds (e.g. "As long as end of file is not reached, read and print out the next character from the file.").

Note: in a wider sense algorithms may be expressed in other (mathematically equivalent) ways than sequences of steps (non-imperative ways, see declarative languages), even mathematical equations are often called algorithms because they imply the steps towards solving a problem. But we'll stick to the common narrow meaning of algorithm given above.

Additional constructs can be introduced to make programming more comfortable, e.g. subroutines/functions (kind of small subprograms that the main program uses for solving the problem), macros (shorthand commands that represent multiple commands) or switch statements (selection but with more than two branches). Loops are also commonly divided into several types such as: counted loops, loops with condition and the beginning, loops with condition at the end and infinite loops (for, while, do while and while (1) in C, respectively) -- in theory there can only be one generic type of loop but for convenience programming languages normally offer different "templates" for commonly used loops. Similarly to mathematical equations, algorithms make use of variables, i.e. values which can change and which have a specific name (such as x or myVariable).

Practical programming is based on expressing algorithms via text, but visual programming is also possible: flowcharts are a way of visually expressing algorithms, you have probably seen some. Decision trees are special cases of algorithms that have no loops, you have probably seen some too. Even though some languages (mostly educational such as Snap) are visual and similar to flow charts, it is not practical to create big algorithms in this way -- serious programs are written as a text in programming languages.

Example

Let's write a simple algorithm that counts the number of divisors of given number x and checks if the number is prime along the way. (Note that we'll do it in a naive, educational way -- it can be done better). Let's start by writing the steps in plain English (sometimes called pseudocode):

1. Read the number x from the input.
2. Set the divisor counter to 0.
3. Set currently checked number to 1.
4. While currently checked number is lower or equal than x:

• a: If currently checked number divides x, increase divisor counter by 1.
• b: Increase currently checked number.

5. Write out the divisor counter.
6. If divisor counter is equal to 2, write out the number is a prime.

Notice that x, divisor counter and currently checked number are variables. Step 4 is a loop (iteration) and steps a and 6 are branches (selection). The flowchart of this algorithm is:

               START
                 |
                 V
               read x
                 |
                 V
       set divisor count to 0
                 |
                 V
       set checked number to 1
                 |
    .----------->|
    |            |
    |            V                no
    |    checked number <= x ? ------.
    |            |                   |
    |            | yes               |
    |            V                   |
    |     checked number    no       |
    |       divides x ? -------.     |
    |            |             |     |
    |            | yes         |     |
    |            V             |     |
    |     increase divisor     |     |
    |       count by 1         |     |
    |            |             |     |
    |            |             |     |
    |            |<------------'     |
    |            |                   |
    |            V                   |
    |     increase checked           V
    |       number by 1     print divisor count
    |            |                   |
    '------------'                   |
                                     V             no
                             divisor count = 2 ? -----.
                                     |                |
                                     | yes            |
                                     V                |
                           print "number is prime"    |
                                     |                |
                                     |<---------------'
                                     V
                                    END

This algorithm would be written in Python as:

x = int(input("enter a number: "))

divisors = 0

for i in range(1,x + 1):
  if x % i == 0: # i divides x?
    divisors = divisors + 1

print("divisors: " + str(divisors))
 
if divisors == 2:
  print("It is a prime!")

in C as:

#include <stdio.h>                                                              
                                                                                 
int main(void)
{
  int x, divisors = 0;
                                                                
  scanf("%d",&x); // read a number

  for (int i = 1; i <= x; ++i)
    if (x % i == 0) // i divides x?
      divisors = divisors + 1;

  printf("number of divisors: %d\n",divisors);
 
  if (divisors == 2)
    puts("It is a prime!");

  return 0;
} 

and in comun as (for simplicity only works for numbers up to 9):

<- "0" -  # read X and convert to number
0         # divisor count
1         # checked number

@@
  $0 $3 > ?     # checked num. > x ?
    !@
  .

  $2 $1 % 0 = ? # checked num. divides x ?
    $1 ++ $:2   # increase divisor count
  .

  ++      # increase checked number
.

0 "divisors: " -->   # write divisor count
$1 "0" + -> 10 ->

$1 2 = ?
  0 "It is a prime" --> 10 ->
.

This algorithm is however not very efficient and could be optimized -- for example there is no need to check divisors higher than the square root of the checked value (mathematically above square root the only divisor left is the number itself) so we could lower the number of the loop iterations and so make the algorithm finish faster.

Study of Algorithms

Algorithms are the essence of computer science, there's a lot of theory and knowledge about them.

Turing machine, a kind of mathematical bare-minimum computer, created by Alan Turing, is the traditional formal tool for studying algorithms, though many other models of computation exist. From theoretical computer science we know not all problems are computable, i.e. there are problems unsolvable by any algorithm (e.g. the halting problem). Computational complexity is a theoretical study of resource consumption by algorithms, i.e. how fast and memory efficient algorithms are (see e.g. P vs NP). Mathematical programming is concerned, besides others, with optimizing algorithms so that their time and/or space complexity is as low as possible which gives rise to algorithm design methods such as dynamic programming (practical optimization is a more pragmatic approach to making algorithms more efficient). Formal verification is a field that tries to mathematically (and sometimes automatically) prove correctness of algorithms (this is needed for critical software, e.g. in planes or medicine). Genetic programming and some other methods of artificial intelligence try to automatically create algorithms (algorithms that create algorithms). Quantum computing is concerned with creating new kinds of algorithms for quantum computers (a new type of still-in-research computers). Programming language design is the art and science of creating languages that express computer algorithms well.

Specific Algorithms

Following are some well known algorithms.

• graphics
  • DDA: line drawing algorithm
  • discrete Fourier transform: extremely important algorithm expressing signals in terms of frequencies
  • Bresenham's algorithm: another line drawing algorithm
  • Midpoint algorithm: circle drawing algorithm
  • flood fill: algorithm for coloring continuous areas
  • FXAA
  • Hough transform: finds shapes in pictures
  • painter's algorithm
  • path tracing
  • ray tracing
  • ...
• math
  • Boot'h algorithm: algorithm for multiplication
  • Dijkstra's algorithm
  • Euclidean algorithm: computes greatest common divisor
  • numerical algorithms: approximate mathematical functions
  • sieve of Eratosthenes: computes prime numbers
  • ...
• sorting
  • bogosort (stupid sort)
  • bubble sort: simple, kind of slow but still usable sorting algorithm
  • heap sort
  • insertion sort
  • merge sort
  • shaker sort
  • selection sort
  • slow sort
  • quick sort: one of the fastest sorting algorithms
  • ...
• searching
  • binary search
  • linear search
  • ...
• other
  • A*: path searching algorithm, used by AI in many games
  • backpropagation: training of neural networks
  • fizzbuzz: problem/simple algorithm given in job interviews to filter out complete noobs
  • FFT: quickly converts signal (audio, image, ...) to its representation in frequencies, one of the most famous and important algorithms
  • Huffman coding: compression algorithm
  • Kalman filter
  • k-means: clustering algorithm
  • MD5: hash function
  • backtracking
  • minimax plus alpha-beta pruning: used by many AIs that play turn based games
  • proof of work algorithms: used by some cryptocurrencies
  • RSA
  • Shor's algorithm: quantum factorization algorithm
  • YouTube algorithm: secret algorithm YouTube uses to suggest videos to viewers, a lot of people hate it :)
  • ...

See Also

• programming
• design pattern
• recursion

Aliasing

See also antialiasing.

Aliasing is a certain typically undesirable phenomenon that distorts signals (such as sounds or images) when they are sampled discretely (captured at single points, usually at periodic intervals) -- this can happen e.g. when capturing sound with digital recorders or when rendering computer graphics. There exist antialiasing methods for suppressing or even eliminating aliasing. Aliasing can be often seen on small checkerboard patterns as a moiré pattern (spatial aliasing), or maybe more famously on rotating wheels or helicopter rotor blades that in a video look like standing still or rotating the other way (temporal aliasing, caused by capturing images at intervals given by the camera's FPS).

A simple example showing how sampling at discrete points can quite dramatically alter the recorded result:

|      .|-'-'.' '           .--.           |   |''''
|  . '  |      ' .        .'    '.         |   |    
'|- - -O+ - -O- - .|     |  O  O  |        '---+---.
 |     \|_ _ /    ||     |  \__/  |            |   |
_ _'_._ |      . '|       '.    .'         ____|   |
       ' ' ' '              ''''
  original image    taking even columns  taking odd columns

The following diagram shows the principle of aliasing with a mathematical function:

^       original                     sampling period                       
|   |               |               |<------------->|
|   |             _ |           _   |         _     |
| .'|'.         .' '|         .' '. |       .' '.   |
|/__|__\_______/____|\_______/_____\|______/_____\__|___
|   |   \     /     | \     /       \     /       \ |
|   |    '._.'      |  '._.'        |'._.'         '|_.'
|   |               |               |               |
|   :               :               :               :
V   :               :               :               :
    :               :               :               :
^   :               :               :               :
|   :               :               :               :
|---o---...____     :               :               :
|   |          '''''o...____        :               :
|___|_______________|______ ''''----o_______________:___
|                                     '''----___    |        
|                                               ''''o---
|     reconstructed                                              
|
V

The top signal is a sine function of a certain frequency. We are sampling this signal at periodic intervals indicated by the vertical lines (this is how e.g. digital sound recorders record sounds from the real world). Below we see that the samples we've taken make it seem as if the original signal was a sine wave of a much lower frequency. It is in fact impossible to tell from the recorded samples what the original signal looked like.

Let's note that signals can also be two and more dimensional, e.g. images can be viewed as 2D signals. These are of course affected by aliasing as well.

The explanation above shows why a helicopter's rotating blades look to stand still in a video whose FPS is synchronized with the rotation -- at any moment the camera captures a frame (i.e. takes a sample), the blades are in the same position as before, hence they appear to not be moving in the video.

Of course this doesn't only happen with perfect sine waves. Fourier transform shows that any signal can be represented as a sum of different sine waves, so aliasing can appear anywhere.

Nyquist-Shannon sampling theorem says that aliasing can NOT appear if we sample with at least twice as high frequency as that of the highest frequency in the sampled signal. This means that we can eliminate aliasing by using a low pass filter before sampling which will eliminate any frequencies higher than the half of our sampling frequency. This is why audio is normally sampled with the rate of 44100 Hz -- from such samples it is possible to correctly reconstruct frequencies up to about 22000 Hz which is about the upper limit of human hearing.

Aliasing is also a common problem in computer graphics. For example when rendering textured 3D models, aliasing can appear in the texture if that texture is rendered at a smaller size than its resolution (when the texture is enlarged by rendering, aliasing can't appear because enlargement decreases the frequency of the sampled signal and the sampling theorem won't allow it to happen). (Actually if we don't address aliasing somehow, having lower resolution textures can unironically have beneficial effects on the quality of graphics.) This happens because texture samples are normally taken at single points that are computed by the texturing algorithm. Imagine that the texture consists of high-frequency details such as small checkerboard patterns of black and white pixels; it may happen that when the texture is rendered at lower resolution, the texturing algorithm chooses to render only the black pixels. Then when the model moves a little bit it may happen the algorithm will only choose the white pixels to render. This will result in the model blinking and alternating between being completely black and completely white (while it should rather be rendered as gray).

The same thing may happen in ray tracing if we shoot a single sampling ray for each screen pixel. Note that interpolation/filtering of textures won't fix texture aliasing. What can be used to reduce texture aliasing are e.g. by mipmaps which store the texture along with its lower resolution versions -- during rendering a lower resolution of the texture is chosen if the texture is rendered as a smaller size, so that the sampling theorem is satisfied. However this is still not a silver bullet because the texture may e.g. be shrink in one direction but enlarged in other dimension (this is addressed by anisotropic filtering). However even if we sufficiently suppress aliasing in textures, aliasing can still appear in geometry. This can be reduced by multisampling, e.g. sending multiple rays for each pixel and then averaging their results -- by this we increase our sampling frequency and lower the probability of aliasing.

Why doesn't aliasing happen in our eyes and ears? Because our senses don't sample the world discretely, i.e. in single points -- our senses integrate. E.g. a rod or a cone in our eyes doesn't just see exactly one point in the world but rather an averaged light over a small area (which is ideally right next to another small area seen by another cell, so there is no information to "hide" in between them), and it also doesn't sample the world at specific moments like cameras do, its excitation by light falls off gradually which averages the light over time, preventing temporal aliasing (instead of aliasing we get motion blur).

So all in all, how to prevent aliasing? As said above, we always try to satisfy the sampling theorem, i.e. make our sampling frequency at least twice as high as the highest frequency in the signal we're sampling, or at least get close to this situation and lower the probability of aliasing. This can be done by either increasing sampling frequency (which can be done smart, some methods try to detect where sampling should be denser), or by preprocessing the input signal with a low pass filter or otherwise ensure there won't be too high frequencies (e.g. using lower resolution textures).

Altruism

Not to be confused with autism.

Altruism means striving for the wellbeing of others, actively performing selfless actions. It is a purely good attitude which we, the LRS, fully embrace. It's no surprise that under capitalism, the rule of evil, altruism is commonly met with hostility or, in the better case, with ridicule.

Rightists often make an extremely funny reasoning error (probably on purpose) to justify their own fascist behavior; they claim that "altruism doesn't exist" because "altruism still seeks to satisfy one's ego and is therefore self interest". Well, firstly this is either wrong, as selflessness isn't defined by obtaining no reward but rather by acting in the interest of others without exploiting them, and secondly even if you define self interest conveniently in a way that makes your claim technically correct, it still completely misses the point! You can behave in a good or evil way, your definitions don't matter. No matter what words you use, you are just trying to excuse fascist behavior in a situation when you can choose to not behave like a fascist -- imagine someone shooting a child and justifying it like "well, I had to do it because I wanted that child's lollipop and I can't behave without self interest because I can't define selflessness".

Anal Bead

To most people anal beads are just sex toys they stick in their butts, however anal beads with with remotely controlled vibration can also serve as a well hideen one-way communication device. Use of an anal bead for cheating in chess has been the topic of a great cheat scandal in 2022 (Niemann vs Carlsen).

Analog

Analog is the opposite of digital.

Analytic Geometry

Analytic geometry is part of mathematics that solves geometric problems with algebra; for example instead of finding an intersection of a line and a circle with ruler and compass, analytic geometry finds the intersection by solving an equation. In other words, instead of using pen and paper we use numbers. This is very important in computing as computers of course just work with numbers and aren't normally capable of drawing literal pictures and drawing results from them -- that would be laughable (or awesome?). Analytic geometry finds use especially in such fields as physics simulations (collision detections) and computer graphics, in methods such as raytracing where we need to compute intersections of rays with various mathematically defined shapes in order to render 3D images. Of course the methods are used in other fields, for example rocket science and many other physics areas. Analytic geometry reflects the fact that geometric and algebraic problem are often analogous, i.e. it is also the case that many times problems we encounter in arithmetic can be seen as geometric problems and vice versa (i.e. solving an equation is the same as e.g. finding an intersection of some N-dimensional shapes).

Fun fact: approaches in the opposite direction also exist, i.e. solving mathematical problems physically rather than by computation. For example back in the day when there weren't any computers to compute very difficult integrals and computing them by hand would be immensely hard, people literally cut physical function plots out of paper and weighted them in order to find the integral. Awesome oldschool hacking.

Anyway, how does it work? Typically we work in a 2D or 3D Euclidean space with Cartesian coordinates (but of course we can generalize to more dimensions etc.). Here, geometric shapes can be described with equations (or inequalities); for example a zero-centered circle in 2D with radius r has the equation x^2 + y^2 = r^2 (Pythagorean theorem). This means that the circle is a set of all points [x,y] such that when substituted to the equation, the equation holds. Other shapes such as lines, planes, ellipses, parabolas have similar equations. Now if we want to find intersections/unions/etc., we just solve systems of multiple equations/inequalities and find solutions (coordinates) that satisfy all equations/inequalities at once. This allows us to do basically anything we could do with pen and paper such as defining helper shapes and so on. Using these tools we can compute things such as angles, distances, areas, collision points and much more.

Analytic geometry is closely related to linear algebra.

Examples

Nub example:

Find the intersection of two lines in 2D: one is a horizontal line with y position 2, the other is a 45 degree line going through the [0,0] point in the positive x and positive y direction, like this:

  y
  :        _/ line 2
  :      _/
_2:_____/_______ line 1
  :  _/
  :_/
--:----------x
_/:
  :

The equation of line 1 is just y = 2 (it consists of all points [x,2] where for x we can plug in any number to get a valid point on the line).

The equation of line 2 is x = y (all points that have the same x and y coordinate lie on this line).

We find the intersection by finding such point [x,y] that satisfies both equations. We can do this by plugging the first equation, y = 2, to the second equation, x = y, to get the x coordinate of the intersection: x = 2. By plugging this x coordinate to any of the two line equations we also get the y coordinate: 2. I.e. the intersection lies at coordinates [2,2].

Advanced nub example:

Let's say we want to find, in 2D, where a line L intersects a circle C. L goes through points A = [-3,0.5] and B = [3,2]. C has center at [0,0] and radius r = 2.

The equation for the circle C is x^2 + y^2 = 2^2, i.e. x^2 + y^2 = 4. This is derived from Pythagorean theorem, you can either check that or, if lazy, just trust this. Equations for common shapes can be looked up.

One possible form of an equation of a 2D line is a "slope + offset" equation: y = k * x + q, where k is the tangent (slope) of the line and q is an offset. To find the specific equation for our line L we need to first find the numbers k and q. This is done as follows.

The tangent (slope) k is (B.y - A.y) / (B.x - A.x). This is the definition of a tangent, see that if you don't understand this. So for us k = (2 - 0.5) / (3 - -3) = 0.25.

The number q (offset) is computed by simply substituting some point that lies on the line to the equation and solving for q. We can substitute either A or B, it doesn't matter. Let's go with A: A.y = k * A.x + q, with specific numbers this is 0.5 = 0.25 * -3 + q from which we derive that q = 1.25.

Now we have computed both k and q, so we now have equations for both of our shapes:

• circle C: x^2 + y^2 = 4
• line L: y = 0.25 * x + 1.25

Feel free to check the equations, substitute a few points and plot them to see they really represent the shapes (e.g. if you substitute a specific x shape to the line equation you will get a specific y for it).

Now to find the intersections we have to solve the above system of equations, i.e. find such couples (coordinates) [x,y] that will satisfy both equations at once. One way to do this is to substitute the line equation into the circle equation. By this we get:

x^2 + (0.25 * x + 1.25)^2 = 4

This is a quadratic equation, let's get it into the standard format so that we can solve it:

x^2 + 0.0625 * x^2 + 0.625 * x + 1.5625 = 4

1.0625 * x^2 + 0.625 * x - 2.4375 = 0

Note that this makes perfect sense: a quadratic equation can have either one, two or no solution (in the realm of real numbers), just as there can either be one, two or no intersection of a line and a circle.

Solving quadratic equation is simple so we skip the details. Here we get two solutions: x1 = 1.24881 and x2 = -1.83704. These are the x position of our intersections. We can further find also the y coordinates by simply substituting these into the line equation, i.e. we get the final result:

• intersection 1: [1.24881, 1.5622025]
• intersection 2: [-1.83704, 0.79074]

See Also

• linear algebra

Anarchism

Anarchism (from Greek an, no and archos, ruler) is a socialist political philosophy rejecting any social hierarchy and oppression, most notably that of capitalism and state but also any other form, e.g. nationalism, identity fascism, hero culture etc. Anarchism doesn't mean without rules, but without rulers; despite popular misconceptions anarchism is not chaos -- on the contrary, it strives for a stable, ideal society of equal people who live in peace. It means order without power. Let's also stress that anarchism is ALWAYS incompatible with and strongly opposes capitalism, as it's sadly heard too many times from the mouth of common people they think anarchism to be something akin "true capitalism" or "free market" (people get very confused by abuse of the word "free") -- NO, capitalism and formal government are an anarchist's two most opposed ideas (and please do not be mislead by attempts at deception e.g. by so called "anarcho capitalists"; such a term just tries to merge two fundamentally incompatible ideas, like for example "militant pacifist" or "communist capitalist"). The symbols of anarchism include the letter A in a circle and a black flag that for different branches of anarchism is diagonally split from bottom left to top right and the top part is filled with a color specific for that branch.

LRS is a truly anarchist movement, specifically anarcho pacifist and anarcho communist one. True, purest anarchism is pacifist, communist and altruistic as that's the perfect ideal of society without hierarchy. Other forms of anarchism that try to sneak in acceptance of concepts such as "justified violence" or some form of "market economy" are mostly just poses of teenage boys who really believe in capitalism but want to adopt a cool label of "anarchist".

A great many things about anarchism are explained in the text An Anarchist FAQ, which is free licensed and can be accessed e.g. at https://theanarchistlibrary.org/library/the-anarchist-faq-editorial-collective-an-anarchist-faq-full.

Anarchism is a wide term and encompasses many flavors such as anarcho communism, anarcho pacifism, anarcho syndicalism, anarcho primitivism or anarcho mutualism. Some of the branches disagree on specific questions, e.g. about whether violence is ever justifiable, or propose different solutions to issues such as organization of society, however all branches of anarchism are socialist and all aim for elimination of social hierarchy such as social classes created by wealth, jobs and weapons, i.e. anarchism opposes state (e.g. police having power over citizens) and capitalism (employers exploiting employees, corporations exploiting consumers etc.).

There exist many fake, pseudoanarchist ideologies such as "anarcho" capitalism (which includes e.g. so caleed crypto "anarchism") that deceive by their name despite by their very definition NOT fitting the definition of anarchism (just like Nazis called themselves socialists despite being the opposite). Also the "new", western pseudoleftist "anarchism" is NOT true anarchism, e.g. "anarcha" feminism is just fascist bullshit. Anything individualist, connected to feminism, LGBT etc. is not true anarchism. The propaganda also tries to deceive the public by calling various violent criminals anarchists, even though they very often can't fit the definition of a true anarchist.

See Also

• communism
• libertarianism

Anarch

Poor man's Doom?

Anarch is a LRS/suckless, free as in freedom first man shooter game similar to Doom, written by drummyfish. It has been designed to follow the LRS principles very closely and set an example of how games, and software in general, should be written. It also tries to be compatible with principles of less retarded society, i.e. it promotes anarchism, anti-capitalism, pacifism etc.

The repo is available at https://codeberg.org/drummyfish/Anarch or https://gitlab.com/drummyfish/anarch. Some info about the game can also be found at the libregamewiki: https://libregamewiki.org/Anarch.

{ Though retrospectively I can of course see many mistakes and errors about the game and though it's not nearly perfect, I am overall quite happy about how it turned out for what it is, it got some attention among the niche of suckless lovers and many people have written me they liked the game and its philosophy. Many people have ported it to their favorite platforms, some have even written me their own expansions of the game lore, tricks they found etc. If you're among them, thank you :) ~drummyfish }

h@\hMh::@@hhh\h@rrrr//rrrrrrrrrrrrrrrrrrrr@@@@hMM@@@M@:@hhnhhMnr=\@hn@n@h@-::\:h
hMhh@@\\@@@\\h:M/r/////rrrrrrrrrrrrrrr//r@@@@@MMh@@hhh\\\=rMr=M@hh\hn\:\:h::\@\:
@nh==hhhMM@hrh\M/r/////rrrrrrrrrrrrrrr//@@@@@@hhM@h\MhhhMM\@@@@@M\hh\\\Mhh\\\\hh
:hh=@Mh/;;;@hr:M,///;;/////rrr//rrrrrr//@@@@@@hh\h@@hM:==h\@@::\\\:M\@\h\M:\:=@h
\=MhM@hr  `hMhhM///@@@@@@@@@@@@@@@@@@@//@@@@@@rMM@n\M=:@M\\\\Mh\\\hr\n\--h-::r:r
:Mh@M@@`  `rh@\@///@@@@@@@@@@@@@@@@@@@@@@@@@@@Mr\@@\h@:\h\h@\Mhh@@\M@@@@-n\rn@:h
:MhhMn@//r;;@/hM@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@MhMhh:M@MhMhMh@\\rM/@h@nn=-MrnM@:h
:nhhhhh\\//\::@M@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@rMM@@nh@M\=nh@@@M@..=hM@n@-@@@@@:h
\@\h@@rrrr/rr@=M@@@@@@@@@@@@@@nr@@@@@@@@@@@@@@Mrhn@\M@:nMh\@@@@@...h:::::@---::h
-M\h=h\`   rhM\M@@@@@@@@@@@@@@@=@@@@@@@@@@@@@@MhM@\hh@M@Mhh@-\MMhrr\\\:MMh::\\-\
h@hhh\h`  `rMh\M@@@@@@@@@@@@@@nr;;;;rn@@@@@@@@r@r///=@\@\r\\hM@nrrr@\n\h\M\\\\\:
hn===hhM=;hhhh\MrMnrr=rrr=r@rhhr;.r,/hr=r=r=h=r@=/-;/MhhMr:h\@h=...r\@hMhM:/\h\=
@n==M\h@=;hhh\\Mrr=r=r=rMr=hrMMr;;;,;========MM@r=./;@:MMM\h=r=rM/rh@@@M-n---:-h
:\=hMn@@@=\hhh:M===============;/. ,,==========@r-/--@:@M\\@@@n@Mn:hM@n@-=\hr=-h
\hhnM@=@::@MM/h================;;;;.,======\h==M=/;r,//;;r=r=r=r@\=r=r=r=@rnMn:r
:Mrrr=rr==@rr=rrr=rrr=/=r===r==/:; ..===r\\-h==@r-,;-=r/;/;;;;;;rnrrr=rrr=rrr=r;
rrrrrrrr@=rrrrrrrrrrr//r=r=r=r=r;. ,.r=r\---hr=@r===-r=r=;;;r;;;hh@:;;;;;;;;;;-;
r=rrr=rr\\@rr=rrr=r/;/:rr=rrr=rr;r,..=r\--.-h=r@r----=rrr=rrr--:,;;:,;;;,;;;,;--
rrrr:-@=====:,;,;-/;/:rrrrrrrrr;;....r\--.,\hrrrrrrrrrrrrrrrrrrrrr-----rrrrrrrrr
,;,:,; ;,;;;-;;;,;/:-rrrrrrrrrrrrrrrrr\-.,;\@rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
;,;,;,.,;,;,;,;,;,:rrrrrrrrrrrrrrrrrr\--.;,\Mrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
,;,;.-.-.-::-:::--rr/rrr/rrr/rrr/rrr/\-.:;::@rrr/rrr/rrr/rrr/rrr/rrr/rrr/rrr/rrr
-.-.r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/\---;::\@/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/
/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r\-.,;:,:@r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r
///////////////////////////////////\::-,;,-:@///////////////////////////////////
;///;///;///;///;///;///;///;///;//,::-:,.,-@///;///;///;///;///;///;///;///;///
//////////////////////////////////\----:-.,-h///////////////////////////////////
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
nn..nnn...nn...nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn...nnnnnnnnnnnnnn
nnn.nnn.n.nn.n.nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn.n.nnnnnnnnnnnnnn
nnn.nnn.n.nn.n.nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn.n.nnnnnnnnnnnnnn
nn...nn...nn...nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn...nnnnnnnnnnnnnn
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn

screenshot from the terminal version

Anarch has these features:

• It is completely public domain free software/free culture under CC0, including all code and assets which were all made from scratch by drummyfish.
• It has extremely low hardware demands, fitting into 256 kB (WITH assets, with mods and compression even 60 kB) and requiring only about 32 kB of RAM and 50 MHz CPU. GPUs need not apply.
• It is written in pure C99 without any dependencies (not even the standard library). It uses no dynamic heap allocation and no floating point.
• It is extremely portable, written against a very tiny I/O layer. As such it has been ported to many platforms such as GNU/Linux, BSD, Pokitto, browser JavaScript, Raspberry Pi and many others.
• It is written in a single compilation unit and without any build system.
• It is created with only free software.
• It is well documented.
• Mods and configs follow suckless philosophy: mods are just diffs, config is part of source code.
• Gameplay-wise Anarch offers 10 levels and multiple enemy and weapon types. It supports mouse where available.

Technical Details

Anarch is written in C99.

The game's engine uses raycastlib, a LRS library for advanced 2D raycasting; this would be called "pseudo 3D" graphics. The same method (raycasting) was used by Wolf3D but Anarch improves it to allow different levels of floor and ceiling which makes it look a little closer to Doom (which however used a different methods called BSP rendering).

The whole codebase (including raycastlib AND the assets converted to C array) has fewer than 15000 lines of code. Compiled binary is about 200 kB big, though with compression and replacing assets with procedurally generated ones (one of several Anarch mods) the size was made as low as 57 kB.

The music in the game is procedurally generated using bytebeat.

All images in the game (textures, sprites, ...) are 32x32 pixels, compressed by using a 16 color subpalette of the main 256 color palette, and are stored in source code itself as simple arrays of bytes -- this eliminates the need for using files and allows the game to run on platforms without a file system.

The game uses a tiny custom-made 4x4 bitmap font to render texts.

Saving/loading is optional, in case a platform doesn't have persistent storage. Without saving all levels are simply available from the start.

In the suckless fashion, mods are recommended to be made and distributed as patches.

Bad Things (Retrospective)

The following is a retrospective look on what could have been done better, written by drummyfish (a potential project for someone might be to implement these and so make the game even more awesome):

• It might have been better to write it in C89 than C99 for better portability.
• Sound effects would likely be better procedurally generated just like music. It would be less code and data in ROM and the quality probably wouldn't be that much worse as the samples are shitty quality anyway.
• The palette used might have rather been RGB 332 instead of the custom palette, again less code and less data in ROM, though visual quality might suffer a bit and things like diminishing colors might require some extra code or look up tables (like in Doom).
• The python scripts for data conversion should be rewritten to C. Using python was just laziness.
• Raycastlib itself has some issues, but those should be addressed separately.
• The game is really a bit too hard (tho this can easily be changed in settings) and gameplay is not great (like explosions pushing player instantly, not too good, too few items, player often lacks ammo/health, ...), movement inertia could be in vanilla game to make it feel nicer etc.
• Some of the code is awkward, like SFG_recomputePlayerDirection was an attempt at optimization but it's probably optimization in a wrong place that does nothing, ...
• Some details like having separate arrays for different types of images -- there is no reason for that, it would be better to just have one huge array of all images; maybe even have ALL data in one huge array of bytes.
• ...

"Anarcho" Capitali$m

Not to be confused with anarchism.

So called "anarcho capitalism" (ancap for short, not to be confused with anpac or any form of anarchism) is probably the worst, most retarded and most dangerous idea in the history since the Big Bang, and that is the idea of supporting capitalism absolutely unrestricted by state or anything else. You'd have to have some worms in your brain to support that. No one with at least 10 brain cells and/or anyone who has spent at least 3 seconds observing the world could come up with such a stupid, stupid idea. We, of course, completely reject this shit.

It has to be noted that "anarcho capitalism" is not real anarchism, despite its name. Great majority of anarchists strictly reject this ideology as any form of capitalism is completely incompatible with anarchism -- anarchism is defined as opposing any social hierarchy and oppression, while capitalism is almost purely based on many types of hierarchies (internal corporate hierarchies, hierarchies between companies, hierarchies of social classes of different wealth etc.) and oppression (employee by employer, consumer by corporation etc.). Why do they call it anarcho capitalism then? Well, partly because they're stupid and don't know what they're talking about (otherwise they couldn't come up with such an idea in the first place) and secondly, as any capitalists, they want to deceive and ride on the train of the anarchist brand -- this is not new, Nazis also called themselves socialists despite being the complete opposite.

The colors on their flag are black and yellow (this symbolizes shit and piss).

It is kind of another bullshit kind of "anarchism" just like "anarcha feminism" etc.

The Worst Idea In History

As if capitalism wasn't extremely bad already, "anarcho" capitalists want to get rid of the last mechanisms that are supposed to protect the people from corporations -- states. We, as anarchists ourselves, of course see states as eventually harmful, but they cannot go before we get rid of capitalism first. Why? Well, imagine all the bad things corporations would want to do but can't because there are laws preventing them -- in "anarcho" capitalism they can do them.

Firstly this means anything is allowed, any unethical, unfair business practice, including slavery, physical violence, blackmailing, rape, worst psychological torture, nuclear weapons, anything that makes you the winner in the jungle system. Except that this jungle is not like the old, self-regulating jungle in which you could only reach limited power, this jungle offers, through modern technology, potentially limitless power with instant worldwide communication and surveillance technology, with mass production, genetic engineering, AI and weapons capable of destroying the planet.

Secondly the idea of getting rid of a state in capitalism doesn't even make sense because if we get rid of the state, the strongest corporation will become the state, only with the difference that state is at least supposed to work for the people while a corporation is only by its very definition supposed to care solely about its own endless profit on the detriment of people. Therefore if we scratch the state, McDonalds or Coca Cola or Micro$oft -- whoever is the strongest -- hires a literal army and physically destroys all its competition, then starts ruling the world and making its own laws -- laws that only serve the further growth of that corporation such as that everyone is forced to work 16 hour shifts every day until he falls dead. Don't like it? They kill your whole family, no problem. 100% of civilization will experience the worst kind of suffering, maybe except for the CEO of McDonald's, the world corporation, until the planet's environment is destroyed and everyone hopefully dies, as death is what we'll wish for.

A typical "anarcho"capitalist is a redneck who probably thinks the only thing preventing him from beating a corporation at its own game is state holding him back with high taxes -- he thinks that if he's allowed to keep all his crops he'll become a beast starting his own business that will go on beating Facebook, i.e. he thinks that if he can keep all five of all five carrots he grows on his field, he will somehow become so powerful he can bring down an army of ten thousand men with the most advanced technology who by the way can now also keep all money it makes, because he heard this in some fairy tale about Henry Ford or something. Of course that's highly laughable and pathetic, but indeed typically American.

All in all, "anarcho" capitalism is advocated mostly by children who don't know a tiny bit about anything, by children who are being brainwashed daily in schools by capitalist propaganda, with no education besides an endless stream of ads from their smartphones, or capability of thinking on their own. However, these children are who will run the world soon. It is sad, it's not really their fault, but through them the system will probably come into existence. Sadly "anarcho" capitalism is already a real danger and a very likely future. It will likely be the beginning of our civilization's greatest agony. We don't know what to do against it other than provide education.

God be with us.

See Also

• capitalism
• libertarianism

Anarcho Pacifism

Anarcho pacifism (anpac) is a form of anarchism that completely rejects any violence. Anarcho pacifists argue that since anarchism opposes hierarchy and oppression, we have to reject violence which is the greatest tool of oppression and establishing hierarchy. This would make it the one true purest form of anarchism. Anarcho pacifists use a black and white flag.

Historically anarcho pacifists such as Leo Tolstoy were usually religiously motivated for rejecting violence, however this stance may also come from logic or other than religious beliefs, e.g. the simple belief that violence will only spawn more violence ("eye for an eye will only make the whole world blind"), or pure unconditional love of life which one simply feels and chooses to follow without the need for any further justification.

We, LRS, advocate anarcho pacifism. We see how violence can be a short term solution, even to preventing a harm of many, however from the long term perspective we only see the complete delegitimisation of violence as leading to a truly mature society. We realize a complete, 100% non violent society may be never achieved, but with enough education and work it will be possible to establish a society with absolute minimum of violence, a society in which firstly people grow up in a completely non violent environment so that they never accept violence, and secondly have all needs secured so that they don't even have a reason for using violence. We should at least try to get as close to this ideal as possible.

Antialiasing

Antialiasing (AA) means preventing aliasing, i.e. distortion of signal (images, audio, video, ...) caused by discrete sampling. Most people think antialiasing stands for "smooth edges in video game graphics", however that's a completely inaccurate understanding of antialiasing: yes, one of the most noticeable effects of 3D graphics antialiasing for a common human is that of having smooth edges, but smooth edges are not the primary goal, they are not the only effect and they are not even the most important effect of antialisng. Understanding antialiasing requires understanding what aliasing is, which is not a completely trivial thing to do (it's not the most difficult thing in the world either, but most people are just afraid of mathematics, so they prefer to stick with "antialiasing = smooth edges" simplification).

The basic sum up is following: aliasing is a negative effect which may arise when we try to sample (capture) continuous signals potentially containing high frequencies (the kind of "infinitely complex" data we encounter in real world such as images or sounds) in discrete (non-continuous) ways by capturing the signal values at specific points in time (as opposed to capturing integrals of intervals), i.e. in ways native and natural to computers. Note that the aliasing effect is mathematical and is kind of a "punishment" for our "cheating" which we do by trying to simplify capturing of very complex signals, i.e. aliasing has nothing to do with noise or recording equipment imperfections, and it may occur not only when recording real world data but also when simulating real world, for example during 3D graphics rendering (which simulates capturing real world with a camera). A typical example of such aliasing effect is a video of car wheels rotating very fast (with high frequency) with a relatively low FPS camera, which then seem to be rotating very slowly and in opposite direction -- a high frequency signal (fast rotating wheels) caused a distortion (illusion of wheels rotating slowly in opposite direction) due to simplified discrete sampling (recording video as a series of photographs taken at specific points in time in relatively low FPS). Similar undesirable effects may appear e.g. on high resolution textures when they're scaled down on a computer screen (so called Moiré effect), but also in sound or any other data. Antialiasing exploits the mathematical Nyquist–Shannon sampling theorem that says that aliasing cannot occur when the sampling frequency is high enough relatively to the highest frequency in the sampled data, i.e. antialiasing tries to prevent aliasing effects typically by either preventing high frequency from appearing in the sampled data (e.g. blurring textures, see MIP mapping) or by increasing the sampling frequency (e.g. multisampling). As a side effect of better sampling we also get things such as smoothly rendered edges etc.

Note that the word anti in antialising means that some methods may not prevent aliasing completely, they may just try to suppress it somehow. For example the FXAA (fast approximate antialiasing) method is a postprocessing algorithm which takes an already rendered image and tries to make it as if it was properly rendered in ways preventing aliasing, however it cannot be 100% successful as it doesn't know the original signal, all it can do is try to give us a good enough approximation.

How to do antialiasing? There are many ways, depending on the kind of data (e.g. the number of dimensions of the signal or what frequencies you expect in it) or required quality (whether you want to prevent aliasing completely or just suppress it). As stated above, most methods make use of the Nyquist–Shannon sampling theorem which states that aliasing cannot occur if the sampling frequency is at least twice as high as the highest frequency in the sampled signal. I.e. if you can make sure your sampling frequency is high enough relatively to the highest frequency in the signal, you will completely prevent aliasing -- you can do this by either processing the input signal with a low pass filter (e.g. blurring an image) or by increasing your sampling frequency (e.g. rendering at higher resolution). Some specific antialiasing methods include:

• avoiding aliasing: A pretty straightforward way :) Aliasing can be avoided e.g. simply by using low resolution textures as opposed to high resolution ones.
• multisampling (MSAA), supersampling (SSAA) etc.: Increasing sampling frequency, typically in computer graphics rendering. The specific methods differ by where and how they increase the number of samples (some methods increase sampling uniformly everywhere, some try to detect aliasing areas and only put more samples there etc). A simple (but expensive) way of doing this is rendering the image at higher resolution and then scaling it back down.
• FXAA: Cheating, approximation of antialiasing by postprocessing, usually in shaders, cheap but can be imperfect.
• MIP mapping: Way of preventing aliasing in rendering of scaled-down textures by having precomputed scaled-down antialiased versions of it.
• anisotrpic filtering: Improved version of MIP mapping.
• motion blur: Temporal antialiasing in video, basically increasing the number of samples in the time domain.
• ...

Code Example

Here is a quite primitive example of supersampling (one of the simplest antialiasing methods) in C. We will draw a two dimensional "fish eye" distorted sine pattern (similar to checkerboard pattern but smooth, to show that aliasing happens even with smooth images!) that gets smaller towards the edges, i.e. the pattern is quite big in the center but near the edges the brightness oscillates with subpixel frequency which will lead to aliasing. First we'll draw the pattern as is, i.e. taking one sample per each pixel, letting aliasing happen; then we'll try to suppress aliasing by taking multiple samples per each pixel and averaging them -- this effectively increases our sampling frequency. It is basically equivalent to drawing the picture in increased resolution and then smoothly downsizing it (but in practice we don't do this as we'd waste a lot of RAM on storing the big resolution picture, which is completely unnecessary). Let's see the code.

#include <stdio.h>
#include <math.h>

#define W 64  // image width
#define H 32  // image height
#define S 9.0 // pattern scale

const char palette[] = "#OVaxsflc/!;,.- ";

double sample(double x, double y) // function sampling our pattern
{
  return sin(S / (x < 0 ? (x + 1) : (1 - x))) *
         sin(S / (y < 0 ? (y + 1) : (1 - y)));
}

char doubleToChar(double x) // maps <-1,1> brightness to palette character
{
  int i = ((x + 1) / 2.0) * 15;
  return palette[i < 0 ? 0 : (i > 15 ? 15 : i)];
}

void draw(int antialiasSamples)
{
  #define OFFSET 0.0001 // this tiny offset makes the pictures a bit nicer

  double
    x, y = -1 + OFFSET,
    stepX = 2.0 / W,
    stepY = 2.0 / H;

  double
    aaStepX = stepX / antialiasSamples,
    aaStepY = stepX / antialiasSamples;

  for (int j = 0; j < H; ++j) // draw rows
  {
    x = -1 + OFFSET;

    for (int i = 0; i < W; ++i) // draw columns
    {
      double r = 0;

      for (int l = 0; l < antialiasSamples; ++l)
        for (int k = 0; k < antialiasSamples; ++k)
          r += sample(x + k * aaStepX,y + l * aaStepY);

      putchar(doubleToChar(r / (antialiasSamples * antialiasSamples)));  
      x += stepX;
    }

    y += stepY;
    putchar('\n');
  }
}

int main(void)
{
  draw(1);
  putchar('\n');
  draw(8);
  return 0;
}

Here are the results, first picture is without any antialiasing, second one with 8x8 supersampling (i.e. taking 64 samples per pixel):

c//xfs/c!fcs/lxf//cfssflc/!//cllfllc//!/clfssfc//fxl/scf!c/sfscl
/,!Vsa;c,x!a,cVs;,cxVVxl!;,,;/cfsfc/;,,;!lxVVxc,;sVc,a!x,/;afVcc
fss/c/sfscf/sl/cssfc//clfssssfllcllfssssflc//cfssc/ls/fcsfs/l/fl
/,;OsV;/.x!V,cOs;,/xVVxl!,.,;!cfsfc!;,.,!lxVVx/,;sOc,V!x./;VfV/c
!-,#sO./-a;O-c#x.-/a##al;.--.;cfxfc;.--.;la##a/-.x#c-O;a-/.#f#/c
c!!afx!c;s/x!caf!!csaxsl/!;;!/clslc/!;;!/lsxasc!!fac!x/s;c!xfacl
/.,#sO,/-a!O.c#s,./a#Oxl;.-.,!cfxfc!,.-.;lxO#a/.,s#c.O!a-/,Of#/c
x#V-/.Os#;a.#f-!O#s;--;laO##Oafc!cfaO##Oal;--;s#O!-f#.a;#sO-c-sf
/,;OsV;/.x!V,cOs;,/xVVxl!,.,;!cfsfc!;,.,!lxVVx/,;sOc,V!x./;VfV/c
c/csfs/c/fcs/lsf//cfssflc////cllfllc////clfssfc//fsl/scf/c/slscl
s#V-/.Vs#;a.#f-/V#s;--;laO##Vafc!cfaO##Oal;--;s#V!-f#.a;#sO.c-sf
fxx;c!xfa/s!xf;cxaf/;!/lsxaaxsfc/lfsxaaxsl/!;/faxc;fx!s/afx!c;fl
c;!afx!c;s/x;caf!;csaasl/!;;!/cfsfc/!;;!/lsaasc;!fac;a/s;c!afacl
!-,#sO./-a;O-c#x.-/a##al;.--.;cfxfc;.--.;la##a/-.x#c-#;a-/.#f#/c
/,;OsV;/.x!V,cOs;,/xVVxl!,.,;!cfsfc!;,.,!lxVVx/,;sOc,V!x./;VfV/c
lccflfclcfcfclflcclfffflccccccllfllcccccclfffflcclflcfcfclcflfll
fxs!c!sfx/s!xl!csxf/!!/lsxxxsfflclffsxxxsl/!!/fxsc!fx!s/xfs!c!fl
lccflfclcfcfclflcclfffflccccccllfllcccccclfffflcclflcfcfclcflfll
/,;OsV;/.x!V,cOs;,/xOVxl!,.,;!cfsfc!;,.,!lxVVx/,;sOc,V!x./;VfV/c
!-,#sO./-a;O-c#x.-/a##al;.--.;cfxfc;.--.;la##a/-.x#c-#;a-/.#f#/c
c;!afx!c;s/x;caf!;csaasl/!;;!/cfsfc/!;;!/lsaasc;!fac;x/s;c!afacl
fax;c!xfa/s!xf;cxaf/;!/lsxaaxsfc/cfsxaaxsl/!;/faxc;fx!s/afx!c;fl
s#V-/.Vs#;a.#f-/V#s;--;laO##Vafc!cfaV##Oal;--;s#V!-f#.a;#sO.c-sf
c/csfs/c/fcs/lsf//cfssflc////cllfllc////clfssfc//fsl/scf/c/slscl
/,;OsV;/.x!V,cOs;,/xVVxl!,.,;!cfsfc!;,.,!lxVVx/,;sOc,V!x./;VfV/c
x#V-/.Os#;a.#f-!O#s;--;laO##Oafc!cfaO##Oal;--;s#O!-f#.a;#sO-c-sf
/.,#sO,/-a!O.c#s,./a#Oxl;.-.,!cfxfc!,.-.;lxO#a/.,s#c.O!a-/,Of#/c
c;!afx!c;s/x!caf!;csaxsl/!;;!/cfsfc/!;;!/lsxasc;!fac!x/s;c!xfacl
!-,#sO./-a;O-c#x.-/a##al;.--.;cfxfc;.--.;la##a/-.x#c-O;a-/.#f#/c
/,;OsV;/.x!V,cOs;./xOVxl!,..;!cfsfc!;..,!lxVOx/.;sOc,V!x./,VfO/c
fffclcflfcfcflccfflcccclffffffllcllfffffflcccclffcclfcfcflfclcll
c/csfs/c/fcs/lsf//cfssflc////cllfllc////clfssfc//fsl/scf/c/slscl

llllllllllllflclfflcccllfffffllllllfffffllccclfflccflcflllllllll
llllllllllllflclfflcccllfffffllllllfffffllccclfflccflcflllllllll
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
llllllllllllclflcclfffllccccclllllllccccllffflcclflclfllllllllll
lllllllllfclfcclfflcccllfffffllllllfffffllccclfflccflcfcllllllll
lllllllccs/lx/!fxsl!!!cfsxxxsflcclfsxxxxfc/!!csxf!/sf/scllfllcll
ffflllcff!xl,xVc.;fVOas/;..,;/lssl/;,..;/faOVf;./aa;ca;sllcflflf
ccclllfccx!lV!,fOac,.,/saOOVasl//lsaVOOVsc;.,caOs,;af;a/llfcfclc
ffflllcff!xl.xOc.,fV#Vs/,--.;/lssl/;.--,/fV#Of;-/Va,ca;xflcfcflf
llllllllllllflclflllcllllfffllllllllfffllllccllfllllllllllllllll
ccclllfcca!lO!.f#Vc.-./sV##OVxl//lsaO##Vsc,-.cV#s,;Vf,a!clscfclc
lllllllllfclsc/lsflc/ccffsssfflcclffsssfflc//lfsfccflcfcllllllll
ffflllcff!sl;sac,;laVafc;,,,!/lfsl/!;,,;/faVaf!,/ax;cx!sllcflflf
ffflllcff;xl.aOc-,fO#Os/,--.,!lssl/,.--,/fV#Of,-/OV,cV,xfl/fcflf
ffflllcff/sl;sac;!laVafc!,,;!/lffl/!;,,;/fxVaf!,cax!cx!sllcflflf
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
lllllllllfclsc/lssl///cfssssfflcclffssssfl///lfsf/cslcfcllllllll
lllllllllcfl/fsl//lsssfc/////clfflcc////clssslc/csf/lfcfllclllll
ffflllcff!xl,xVc.;fVOVs/;...;/lssl/;,..,/faOVf;./Va,ca;sllcfcflf
ffflllcff!xl.xOc-,fV#Vs/,--.,!lssl/;.--,/fV#Of;-/Va,ca;xfl/fcflf
lllllllllcfl/fsl//lsssfc/////clfflc/////clsssl//css/ls/fllclllll
ccclllfccx/la/;fVal;,;cfaVVVxslc/lsxaVVasc;,;cxVs;!af!x/llfclclc
ccclllfccx!lV!,fOac,.,/saOOVasl//lsaVOOasc;.,caOs,;af;a/llfclclc
ffflllcff/sl;sac;!laVxfc!;,;!/lfflc!;,;!/fxVaf!;cxx!cx!sllcllflf
lllllllllcfl/fsl//lsssfc////cclfflcc////clssslc/csf/lfcfllllllll
cccllllccs/la/;faxl!;!cfxaVaxslcclfxaaaxsc!;;cxaf!!xf!x/llfllclc
lllllllllcflcfflcclfffllcccccllllllcccccllffflcclffclfclllllllll
fffllllff/sl;sac;!lxaxfc!;,;!/lfflc!;;;!/fxaaf!;cxx!cx!sllcllflf
llllllllllllllllflllcllllffflllllllllffllllclllfllllllllllllllll
lllllllllcflcfflcclfsfllc//cccllllccc//cclfsflc/lffclfcfllllllll
llllllllllllllflclllfllllcccllllllllcccllllflllcllllllllllllllll
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

It's a bit harder to see with ASCII art but still it is noticeable even here (the more it will be seen in "real" graphics) -- the first version of the image is much noisier, despite the underlying pattern itself being smooth, just sampled differently. Notice the images really significantly differ near the edges where aliasing appears, the center is basically the same -- here we can spot an obvious weakness of supersampling: that we have wasted computational power on supersampling the part which didn't need it. You can think of ways how this could be improved. Also think for example about placing our samples within one pixel differently than in a uniform grid -- what effect would it have? Here are things for you to explore.

Antivirus Paradox

{ I think this paradox must have had another established name even before antiviruses, but I wasn't able to find anything. If you know it, let me know. ~drummyfish }

Antivirus paradox is the paradox of someone who's job it is to eliminate certain undesirable phenomenon actually having an interest in keeping this phenomenon existing so as to keep his job. A typical example is an antivirus company having an interest in the existence of dangerous viruses and malware so as to keep their business running; in fact antivirus companies themselves secretly create and release viruses and malware.

Cases of said behavior are common, e.g. the bind-torture-kill serial killer used to work as a seller of home security alarms who installed alarms for people who were afraid of being invaded by the bind-torture-killer, and then used his knowledge of the alarms to break into the houses -- a typical capitalist business. It is also a known phenomenon that many firefighters are passionate arsonists because society simply praises them for fighting fires (as opposed to rewarding them for the lack of fires).

In capitalism and similar systems requiring people to have jobs this paradox prevents progress, that is to say actual elimination of undesirable phenomena, hence capitalism and similar systems are anti-progress. And not only that, the system pressures people to artificially creating new undesirable phenomena (like a "lack of women in tech" and similar bullshit) just to create new bullshit jobs that "fight" this phenomena. In a truly good society where people are not required to have jobs and in which people aim to eliminate work this paradox largely disappears.

Apple

"Think different: conform."

Apple is a terrorist organization and one of the biggest American computer fashion corporations, infamously founded by Steve Job$, it creates and sells overpriced, abusive, highly consumerist proprietary electronic devices.

See also http://techrights.org/wiki/Apple%27s_Dark_Side.

App

App is a retarded capitalist name for application; it is used by soydevs, corporations and normalfaggots (similarly to how "coding" is used for programming). This word is absolutely unacceptable and is only to be used to mock these retards.

Anything called an "app" is expected to be bloat, badly designed and, at best, of low quality (and, at worst, malicious).

Approximation

Approximating means calculating or representing something with lesser than best possible precision -- estimating -- purposefully allowing some margin of error in results and using simpler mathematical models than the most accurate ones: this is typically done in order to save resources (CPU cycles, memory etc.) and reduce complexity so that our projects and analysis stay manageable. Simulating real world on a computer is always an approximation as we cannot capture the infinitely complex and fine nature of the real world with a machine of limited resources, but even within this we need to consider how much, in what ways and where to simplify.

Using approximations however doesn't have to imply decrease in precision of the final result -- approximations very well serve optimization. E.g. approximate metrics help in heuristic algorithms such as A*. Another use of approximations in optimization is as a quick preliminary check for the expensive precise algorithms: e.g. using bounding spheres helps speed up collision detection (if bounding spheres of two objects don't collide, we know they can't possibly collide and don't have to expensively check this).

Examples of approximations:

• Distances: instead of expensive Euclidean distance (sqrt(dx^2 + dy^2)) we may use Chebyshev distance (dx + dy) or Taxicab distance (max(dx,dy)).
• Engineering approximations ("guesstimations"): e.g. sin(x) = x for "small" values of x or pi = 3 (integer instead of float).
• Physics engines: complex triangle meshes are approximated with simple analytical shapes such as spheres, cuboids and capsules or at least convex hulls which are much easier and faster to deal with. They also approximate relativistic physics with Newtonian.
• Addition/subtraction (of integers) can sometimes be approximated with logical OR/AND operations, as they behave a bit similarly. This can be used e.g. for brightening/darkening of pixel colors in 332 or 565 format -- without the approximation addition of colors in these formats is very expensive (basically requires conversion to RGB, addition, clamping and a conversion back).
• Square root/square (integer) can be roughly approximated too. E.g. to get a quick "almost square" of a number you can try something like doubling each binary digit and shifting everything right, e.g. 101 -> 11001 -- it's not very accurate but may be good enough e.g. for some graphics effects and may be especially effective as hardware implementation as it works instantly and uses literally no logic gates (you just reorder bits)! A bit improved version may construct a pair of digits from each digit as logical AND (upper bit) and logical OR (lower bit) of the bit with its lower neighbor (lowest bit may still just be doubled), e.g. 1101 -> 11010111. Square root can similarly be roughly estimated by reducing each pair of bits with logical OR sown to a single bit (e.g. 101100 -> 110). { Dunno if this is actually used anywhere, I came up with this once before I fell asleep. ~drummyfish } A famous hack in Quake, called fast inverse square root, uses a similar approximation in floating point.
• 3D graphics is almost completely about approximations, e.g. basically all shapes are approximated with triangle meshes, screen space effects (like SSAO) are used to approximate global illumination, reflections etc. Similarly ray tracing neglects indirect lighting etcetc.
• Real numbers are practically always approximated with floating point or fixed point (rational numbers).
• Numerical methods offer generality and typically yield approximate solutions while their precision vs speed can be adjusted via parameters such as number of iterations.
• Taylor series approximates given mathematical function and can be used to e.g. estimate solutions of differential equations.
• Primitive music synthesis often uses simple functions like triangle/saw/square wave to approximate sin waves (though many times it's done for the actual sound of these waves, sometimes it may be simply to save on resources).
• ...

Arch Linux

"BTW I use Arch"

Arch Linux is a rolling-release Linux distribution for the "tech-savvy", mostly fedora-wearing weirdos.

Arch is shit at least for two reasons: it has proprietary packages (such as discord) and it uses systemd. Artix Linux is a fork of Arch without systemd.

Arduboy

Arduboy is an Arduino-based, extremely tiny indie/"retro" handheld open gaming console, about the size of a credit card, with monochrome (black&white) display; it was one of the earliest during the open console boom and is at the same time among the best in many aspects (construction, hardware, community, games, price, ...). Not only is it one of the top open consoles out there, it is also one of the most minimalist and a great way to get into low level programming, learning C, embedded development etc. Even for a normie not intending to program it it's just a super cool toy to play old nostalgic games on and flex with around friends. We can really recommend getting Arduboy ASAP to anyone remotely interested in this kind of stuff. Arduboy is a bit similar to the original Gamebuino (the one with monochrome screen), it may have been inspired by it. The official website is https://www.arduboy.com/.

  _________
 |.-------.|
 ||ARDUBOY||
 ||_______||
 |         |
 | _||_ /O |
 | ";;" O/ |
 |_________|

Hasted Arduboy ASCII art.

Arduboy has a number of hack/mods, both official and unofficial, see e.g. Arduboy FX (version that comes with memory for games so one doesn't have to use external PC to switch between them) or Arduboy Mini (yet physically smaller version).

{ Let's make it clear I AM NOT PAID for this article :D Reading through it it sounds like I'm shilling it super hard but it's really just that I like Arduboy, it was my first open console and I owe it my change in direction in programming. Of course, Arduboy does have its flaws, it's still something designed for profit, it shills open soars, forums need JavaScript and it's very possible it will become more spoiled in the future, however at the moment it's something quite nice with the amount of capitalist bullshit being still tolerable. That may change but as of writing this it still seems to be so. ~drummyfish }

Arduboy is not very expensive, one can even build it at home, there is documentation. The one you buy has excellent construction, it doesn't suffer from any shortcomings often seen in other such devices (hard to press buttons, display visibility angles, ... ), the monochrome display is tiny but very good, with great contrast, it is joy to just look at; some people even managed to "fake" multiple shades of gray by fast pixel flickering. Seeing games on this display is somehow magical.

As can be judged from the name, Arduboy is based on Arduino (the famous free hardware platform), seems like Arduino Leonardo. The console is very small not only physically but also by its hardware specification, and that even compared to other open consoles -- Arduboy only has 2.5 KB of RAM which is really low, however this is good for learning good programming and testing minimalist software; less is more. Besides this there is 1 KB of EEPROM (for things like game saves, ...) and 32 KB of flash memory (memory for the program itself -- as RAM is so low, one often tries to store data here). The CPU is 8bit ATmega32u4 clocked at 16 MHz (also not very much, good for minimalism). It's an AVR CPU which has a Harvard architecture, i.e. program resides in different memory than the data; this can be something new to PC programmers as you have to think what (and how) to place into the program memory (flash) vs the RAM (as there is very little RAM); basically you have to use the PROGMEM macro to tell Arduino you want something placed in the flash (however that data will then be read-only; the whole PROGMEM thing can be a bit of annoyance, but in the end this is how small computers work). The vanilla version has no SD card. There are 6 buttons: arrows, A and B and that's it -- one often has to think of how to make clever controls with this limited number of buttons (another kind of minimalist exercise). The display is monochrome, 128x64 pixels. For programming one typically uses Arduino IDE and the official Arduboy library (FOSS), but it's easy to do everything from the command line. There is also some kind of speaker for making beeps. Arduboy also has a good emulator, something that greatly helps with development which also isn't standard in the open console world.

Arduboy way designed by Kevin Bates through Kickstarter in 2015, He still keeps improving it and regularly gets involved in discussions on the official forums, that's pretty cool, he shares details and ideas about what he's currently doing, he gets involved in discussing hacks etc. The community is also very nice and greatly active itself -- yes, there are probably some rules on the forums, most people are absolute uber noobs, but it just seems like politics, furriness and similar poison just doesn't get discussed there, everyone just shares games, advice on programming etc., it's pretty bearable. In this it's similar to Pokitto -- there the community is also nice, active, with the creator getting involved a lot.

Games, mostly made by the users themselves, can either be found on the official website or in Erwin's Arduboy game collection (https://arduboy.ried.cl/) which as of writing this lists something over 300 games -- some are pretty impressive, like Arduventure, a pokemon-look-alike RPG game with quite huge world (very impressive for such tiny amount of memory), MicroCity, Catacombs of the Damned or various other similar raycasting 3Dish games. If you don't have Arduboy yet, you can play any game in the emulator (which even runs in the browser), however the experience of playing on the small device cannot indeed be replicated. The console can only hold one game at a time, so you always have to upload another one through USB if you want to switch, though the Arduboy FX mod addresses this by adding additional game memory to the console. Game progress is saved in EEPROM so you shouldn't lose your save states by uploading a new game (unless that game carelessly uses the same space in EEPROM for its own savestates). Great many of the games are FOSS, i.e. come with a free license or at least with the source code, only a minority has secret source code. Some LRS software run on Arduboy, e.g. SAF, so also games like microTD and smolchess, though for example Anarch is too much for this small hardware. Comun C interpreter also ran on Arduboy.

How free is it? Quite a lot, though probably not 100% (if spying is your concern then know this small thing probably won't even be capable of trying to hurt you this way). Arduboy Schematics are available { Not sure about license. ~drummyfish }, forums have tons of additional documentation and tutorials, Arduboy library is free licensed (BSD 3 clause), Arduino itself also uses free licenses (though of course it won't likely be free down to individual transistors...), games are very often free too. Being a minimalist computer there is a great deal of practical freedom. All in all, it's one of the most "overall" free things you can get.

Art

There is no indecency in art.

Art is an endeavor that seeks discovery and creation of beauty and primarily relies on intuition, its value is in feelings it gives rise to. While the most immediate examples of art that come to mind are for example music and painting, even the most scientific and rigorous effort like math and programming becomes art when pushed to the highest level, to the boundaries of current knowledge where intuition becomes important for further development.

Good art always needs time, usually a lot of time, and you cannot predict how much time it will need, art cannot be made on schedule or as a product. By definition creating true art is never a routine (though it requires well trained skills in routine tasks), it always invents something new, something no one has done before (otherwise it's just copying that doesn't need an artist) -- in this sense the effort is the same as that of research and science or exploring previously unwalked land, you can absolutely never know how long it will take you to invent something, what complications you will encounter or what you will find in an unknown land. You simply do it, fail many times, mostly find nothing, you repeat and repeat until you find the good thing. For this art also requires a lot of effort -- yes, there are cases of masterpieces that came to be very casually, but those are as rare as someone finding a treasure by accident. Art is to a great degree a matter of chance, trial and error, the artist himself doesn't understand his own creation when he makes it, he is only skilled at searching and spotting the good, but in the end he is just someone who invests a lot of time into searching, many times blindly.

See Also

• beauty
• databending
• music

ASCII Art

ASCII art is the art of (mostly manually) creating graphics and images only out of fixed-width (monospace) ASCII characters. Strictly speaking this means no Unicode or extended ASCII characters are allowed -- these would rather be called Unicode art, ANSI art etc., though the term ASCII art is quite often used loosely for any art of this kind. If we keep being pedantic, ASCII art might also be seen as separate from mere ASCII rendering, i.e. automatically rendering a bitmap image with ASCII characters in place of pixels, and ASCII graphics that utilizes the same techniques as ASCII art but can't really be called art (e.g. computer generated diagrams); though in practice this distinction is also rarely made. Pure ASCII art is plain text, i.e. it can't make use of color, text decoration and other rich text formatting.

This kind of art used to be a great part of the culture of earliest Internet and near-Internet (e.g. BBS) communities for a number of reasons imposed largely by the limitations of old computers -- it could be created easily with a text editor and saved in pure text format, it didn't take much space to store or send over a network and it could be displayed on text-only displays and terminals. The idea itself even predates computers, people were already making this kind of images with type writers, e.g. some poets were formatting their poems with typewriters to picture-shapes. Despite the technical limitations of displays having been overpassed, ASCII art survives even to present day and lives on in the hacker culture, among programmers, in Unix and "retro" game communities as well as on the Smol Internet, among people who just want to keep it simple and so on. ASCII diagram may very well be embedded in a comment on a text-only forum or in source code to explain some spatial concept. ASCII art may even be superior for making certain types of drawings from purely user perspective exactly by being simplified, it can be performed merely with keyboard with little distraction (not caring about colors, not having to focus on right angles, to care about line thicknesses, switching tools, deleting imprecise strokes, ...), similarly to how for example it may be easier to create a rough model of a house in Minetest than to model it in Blender. { I found that for making quick diagrams I prefer ASCII art to graphic tools. ~drummyfish } We, LRS, highly advocate use of ASCII art whenever it's good enough.

Here is a simple 16-shade ASCII palette (but watch out, whether it works will depend on your font): #OVaxsflc/!;,.- . Another one can be e.g.: WM0KXkxocl;:,'. .

Here are approximate brightness values for each printable ASCII character, with 0 being black and 1000 white (of course the values always depend on the specific font you use):

{ I obtained the values by shooting a screen with some generic monospace font in gedit or something, then made a script that computed the values and ordered them. ~drummyfish }

@ 577    P 727    A 777    ? 827    / 867
W 615    w 735    Z 777    I 830    > 867
M 640    3 740    h 779    j 831    \ 867
0 641    X 741    Y 786    C 834    < 868
Q 656    D 744    [ 797    ) 836    c 870
& 658    V 745    T 797    ( 837    + 874
% 664    b 746    e 798    l 837    J 892
R 664    p 747    } 800    x 838    " 911
8 676    5 748    a 800    i 848    ; 912
# 685    d 748    { 803    z 851    _ 912
O 685    2 750    ] 809    r 853    ~ 924
$ 687    4 750    y 810    ^ 854    : 936
B 702    S 750    1 811    s 855    , 942
6 707    q 751    7 812    v 855    - 953
9 708    k 759    F 812    ! 856    ' 954
g 711    G 765    o 813    t 856    . 968
N 715    K 767    f 815    * 857    ` 969
U 724    E 768    u 825    = 860      1000
m 727    H 771    n 826    L 866

And here are some attempts at actual ASCII art:

            _,,_  
           /    ';_  
    .     (  0 _/  "-._
    |\     \_ /_==-"""'           .~~~~~~~~;~~~~~~~~.
    | |:---'   (                  | ASCII  | tables |
     \ \__."    ) Steamer         |========I========|
      '--_ __--'    Duck!         |  are   |        |
          |L_                     |--------{   =)   |
                                  |  the   |        |
                                  |--------+--------|
      []  [][][][][]              |  best  | tables |
      [][][]      [][]            |________|________|
      [][]          []
      []    XX    XX[]
      []      XXXX  []
      [][]          []        ____   _____   _____
      [][][]      [][]       [   _) [   _ \ / ____]
      []  [][][][][]          ) {    } |_) )\___  \
                              | |__/||  _ {  ___} |
          SAF FTW             }_____|}_{ \_][_____/

   ("\/") ("\/") ("\/")
   \    / \    / \    /
    \  /   \  /   \  /          KEEP IT SIMPLE
     \/     \/     \/             ~~ BRUH ~~
^
|
|   _.--._                  _.--._
| .'      '.              .'      '.
|/__________\____________/__________\______
|            \          /            \
|             '.      .'              '.
|               `'--'`                  `'-
|
V
                                    /|_/| why is
  '.|.'       . :       ___        (._. ) everyone
 --{O}--   .;::.':.' __{   )_      /\  /) so
  .'|'. _.:''  '  : {_ \  } _}       VV   retarded
    ,__|| |_,         \_{__/
   /\\ \|_| \\          __           _    .-.
  /  \\      \\       ,'  '.        (_) __ \ \
 /____\\______\\     ( o    )        _ |__] ) )
  \,,,|,,,,,,,/       '")("o        (_)    / /
  |___|_[H]___|=|=|=|=|=|=|=|=|           '-'

        _                _          ___         _       _ 
  ____ | |__    ___   __| |  ___   / __] ____  | |     (_)
 / _  ]|  _ \  / __] / _  | / _ \ [  _] / _  ] | '--.  ;";
( (_| {| |_) )| (__ ( (_| ||  ___) | | ( (_| | | .-. | | |
 \____]|____/  \___] \____| \___]  |_|  \__  | |_| |_| |_|
   _   _      _                         [___/
  (_) | | __ | |  _   _  ____    ___   ____    ____   ____
  ;"; | |/ / | | | "-" ||  _ '. / _ \ |  _ \  / _  | |  _ |
  | | |   {  | | | ;_; || | | |( (_) )| |_) )( (_| | | | "'
 _/ | |_|\_] \_\ |_| |_||_| |_| \___/ |  __/  \__  | |_|
 \-"     _                            |_|        |_|
  ____  | |   _  _  _   _   _    _   _   _   _   _   ____
 (  __|[   ] | || || [ ] | | |/\| | | \_/ | [ | | | |__  ]
  \_"\  | |_ | || | \ " /  | '  ' |  } _ {   \ \| |  ,' /
 [____) (___]',__,'  \_/    \_/\_/  |_/ \_|  _)  /  |____]
                                            \_.-'

The following is a raster picture auto-converted to ASCII: { For copyright clarity, it's one of my OGA pictures. ~drummyfish }

             !.-
            clxVl.
             c###xl,
          ,.- -,/ac/l!,
       .,,,;;,.;.---!c..;.-
    -!;.;,;cl;c##aV#s,....ca//cfs!;;.--,,,;
   !;;/s/,,c/slc;,;/#l!as;!f/c;;cVOfOf;---.s#c-
  -OOfl,,,,;/,,,!ll.!;!,,!c/!;;!/;cxxO/.;aO##a/,.,!,c;.
   !,;,,,,!!,/f/c!a,,,!//c;;;;;;;!cVOV/lf/......------,l/;.---
  !.!/!/!/;,//c!  ;#s,///;;;;;;!c/a#l;-.----....------.,...,..;,-
   ;x/;;;cslsac    #a!,,;;/,,./casl,---..!cxfs/.,.,!x#xl....-.;,/l,
      -;;;;;-     s;!V....;;;lca#/.---;f#Vxcf######s;.,..-----,,;ssa.
                 xxl!,,,.!,//c##l   ;/c!.,;....c#/.;ac,.,----.,,,fs;a,
                 !Os;!!c,scfa##x-  ---,,,,/,,..###x#;.,!-!,-.lc/cfx/#f
                  xOOs##lO##f;;,   ,-,,,,,,,;l#V;,!/,,,;.#--l#.;;/!,,#!
                     - !##,,,,,  -ax;,,,,,.,f/...c//!./;-#,-##!,,c! ,l;/-
                       /#c- -/,  ##/;,,,,,;./,,,;lclll/ -.V##.,,,c!  !.,/;
                       /##! -.;,;#/,,,,,;,l,,,,,sl,x### - ,#/,,,,c;   c,.,l/.
                        ls#,,,,l.#f.,,,.ff/;;;;O;  ;l/s ---;#;,,;V     ./lOcfl!.-
                        .lf#;,;/!Vl,,,,,xccccs/     ac/,--xf;,,,;#         #////f#l,
                         l/cflc/;.;al/;lclx!,       .f//--.;,,,,O           f/fcx##l.
                         ;s////l-;f#;,;,--           s//f;,,!,,;/            l#xf.c/!!
                         ,;,//!--;;,,,c              !///x.,,,,f-            -c/f  ./,/
                        ,fl!flll.,!/cc,             .ll//f;,,,,/;            !;;.   ,,;/
                       lf;!;!O/,;c;l!fc            -fllclc/!!,,!l         -,;;!-     ;;!
                        ////cc;llVcl/f             #s/lccx;.!/c/c.     .,lc!,        !;;
                      ./,,,!c--..,,,!              x//cf#fscf/c/f.   c,f;           ;;!
                    -f///!!;---,.,!,f            .cc!;/!f;;;//sf.   .fl!         !flls,
                      -  fxl;#/!V/fc/                 l! ,!;;;c     ;l/lc-     ,#Olcs;
                         - -!,-,l!;                   x.;a!/cfc      ./ff;       !.-

{ TODO: what would ASCII art made of ASCII font look like??? ~drummyfish }

The are many tools for this, but for educational purposes this one was made using the following custom C program:

#include <stdio.h>

const char palette[] = "#OVaxsflc/!;,.- ";

int readNum(void)
{
  int r = 0;

  while (1)
  {
    char c = getchar();

    if (c > '9' || c < '0')
      break;

    r = r * 10 + c - '0';
  }

  return r;
}

void skipAfterNewline(void)
{
  while (getchar() != '\n');
}

int main(void)
{
  skipAfterNewline(); // skip magic number
  skipAfterNewline(); // skip header

  int w = readNum();  // read width
  int h = readNum();  // read height

  skipAfterNewline(); // skip to pixels

  for (int j = 0; j < h; ++j) // read rows
  {
    for (int i = 0; i < w; ++i) // read columns
    {
      /* The following is a bit cryptic way of reading RGB, averaging it (giving
        higher significance to green, for human sight bias) to convert it to
        grayscale and then getting it to range 0 to 15 (palette size). */
      int v = ((getchar() + getchar() * 2 + getchar()) * 16) / (4 * 256);
      putchar(palette[v]);
    }

    putchar('\n');
  }

  return 0;
}

This program is extremely simple, it just reads an image in PPM format on standard input and outputs the image to terminal. Watch out, it won't work for all PPM images -- this one worked with a picture exported from GIMP in raw RGB PPM. Also note you have to scale the image down to a very small size AND its aspect ratio has to be highly stretched horizontally (because text characters, i.e. pixels, are much more tall than wide). Also for best results you may want to mess with brightness, contrast, sharpness etc.

See Also

• ANSI art
• ASCII animation (e.g. vt100 terminal animations, asciinema, ...)
• pixel art
• plain text
• emoticon
• cowsay
• figlet

ASCII

ASCII (American standard code for information interchange) is a relatively simple standard for digital encoding of text that's one of the most basic and probably the most common format used for this purpose. For its simplicity and inability to represent characters of less common alphabets it is nowadays quite often replaced with more complex encodings such as UTF-8 who are however almost always backwards compatible with ASCII (interpreting UTF-8 as ASCII will give somewhat workable results), and ASCII itself is also normally supported everywhere. ASCII is the suckless/LRS/KISS character encoding, recommended and good enough for most programs.

The ASCII standard assigns a 7 bit code to each basic text character which gives it a room for 128 characters -- these include lowercase and uppercase English alphabet, decimal digits, other symbols such as a question mark, comma or brackets, plus a few special control characters that represent instructions such as carriage return which are however often obsolete nowadays. Due to most computers working with 8 bit bytes, most platforms store ASCII text with 1 byte per character; the extra bit creates a room for extending ASCII by another 128 characters (or creating a variable width encoding such as UTF-8). These extensions include unofficial ones such as VISCII (ASCII with additional Vietnamese characters) and more official ones, most notably ISO 8859: a group of standards by ISO for various languages, e.g. ISO 88592-1 for western European languages, ISO 8859-5 for Cyrillic languages etc.

The ordering of characters has been kind of cleverly designed to make working with the encoding easier, for example digits start with 011 and the rest of the bits correspond to the digit itself (0000 is 0, 0001 is 1 etc.). Corresponding upper and lower case letters only differ in the 6th bit, so you can easily convert between upper and lower case by negating it as letter ^ 0x20. { I think there is a few missed opportunities though, e.g. in not putting digits right before letters. That way it would be very easy to print hexadecimal (and all bases up to a lot) simply as putchar('0' + x). UPDATE: seen someone ask this on some stack exchange, the answer said ASCII preferred easy masking or something, seems like there was some reason. ~drummyfish }

ASCII was approved as an ANSI standard in 1963 and since then underwent many revisions every few years. The current one is summed up by the following table:

See Also

• Unicode
• PETSCII
• ATASCII
• ASCII art
• base64
• Morse code

Assembly

Assembly (also ASM) is, for any given hardware computing platform (ISA, basically a CPU architecture), the lowest level programming language that expresses typically a linear, unstructured (i.e. without nesting blocks of code) sequence of CPU instructions -- it maps (mostly) 1:1 to machine code (the actual binary CPU instructions) and basically only differs from the actual machine code by utilizing a more human readable form (it gives human friendly nicknames, or mnemonics, to different combinations of 1s and 0s). Assembly is converted by assembler into the the machine code, something akin a computer equivalent of the "DNA", the lowest level instructions for the computer. Assembly is similar to bytecode, but bytecode is meant to be interpreted or used as an intermediate representation in compilers while assembly represents actual native code run by hardware. In ancient times when there were no higher level languages (like C or Fortran) assembly was used to write computer programs -- nowadays most programmers no longer write in assembly (majority of zoomer "coders" probably never even touch anything close to it) because it's hard (takes a long time) and not portable, however programs written in assembly are known to be extremely fast as the programmer has absolute control over every single instruction (of course that is not to say you can't fuck up and write a slow program in assembly).

Assembly is NOT a single language, it differs for every architecture, i.e. every model of CPU has potentially different architecture, understands a different machine code and hence has a different assembly (though there are some standardized families of assembly like x86 that work on wide range of CPUs); therefore assembly is not portable (i.e. the program won't generally work on a different type of CPU or under a different OS)! And even the same kind of assembly language may have several different syntax formats that also create basically slightly different languages which differ e.g. in comment style, order of writing arguments and even instruction abbreviations (e.g. x86 can be written in Intel or AT&T syntax). For the reason of non-portability (and also for the fact that "assembly is hard") you mostly shouldn't write your programs directly in assembly but rather in a bit higher level language such as C (which can be compiled to any CPU's assembly). However you should know at least the very basics of programming in assembly as a good programmer will come in contact with it sometimes, for example during hardcore optimization (many languages offer an option to embed inline assembly in specific places), debugging, reverse engineering, when writing a C compiler for a completely new platform or even when designing one's own new platform (you'll probably want to make your compiler generate native assembly, so you have to understand it). You should write at least one program in assembly -- it gives you a great insight into how a computer actually works and you'll get a better idea of how your high level programs translate to machine code (which may help you write better optimized code) and WHY your high level language looks the way it does.

OK, but why doesn't anyone make a portable assembly? Well, people do, they just usually call it a bytecode -- take a look at that. C is portable and low level, so it is often called a "portable assembly", though it still IS significantly higher in abstraction and won't usually give you the real assembly vibes. Forth may also be seen as close to such concept. ACTUALLY Dusk OS has something yet closer, called Harmonized Assembly Layer (see https://git.sr.ht/~vdupras/duskos/tree/master/fs/doc/hal.txt). Web assembly would also probably fit the definition.

The most common assembly languages you'll encounter nowadays are x86 (used by most desktop CPUs) and ARM (used by most mobile CPUs) -- both are used by proprietary hardware and though an assembly language itself cannot (as of yet) be copyrighted, the associated architectures may be "protected" (restricted) e.g. by patents (see also IP cores). RISC-V on the other hand is an "open" alternative, though not yet so wide spread. Other assembly languages include e.g. AVR (8bit CPUs used e.g. by some Arduinos) and PowerPC.

To be precise, a typical assembly language is actually more than a set of nicknames for machine code instructions, it may offer helpers such as macros (something akin the C preprocessor), pseudoinstructions (commands that look like instructions but actually translate to e.g. multiple instructions), comments, directives, automatic inference of opcode from operands, named labels for jumps (as writing literal jump addresses would be extremely tedious) etc. I.e. it is still much easier to write in assembly than to write pure machine code even if you knew all opcodes from memory. For the same reason remember that just replacing assembly mnemonics with binary machine code instructions is not yet enough to make an executable program! More things have to be done such as linking libraries and converting the result to some executable format such as elf which contains things like header with metainformation about the program etc.

How will programming in assembly differ from your mainstream high-level programming? Quite a lot, assembly is extremely low level, so you get no handholding or much programming "safety" (apart from e.g. CPU operation modes), you have to do everything yourself -- you'll be dealing with things such as function call conventions, interrupts, syscalls and their conventions, counting CPU cycles of individual instructions, looking up exact hexadecimal memory addresses, opcodes, defining memory segments, dealing with endianness, raw goto jumps, call frames etc. You have no branching (if-then-else), loops or functions, you make these yourself with gotos. You can't write expressions like (a + 3 * b) / 10, no, you have to write every step of how to evaluate this expression using registers, i.e. something like: load a to register A, load b to register B, multiply B by 3, add register B to A, divide A by 10. You don't have any data types, you have to know yourself that your variables really represent signed values so when you're dividing, you have to use signed divide instruction instead of unsigned divide -- if you mess this up, no one will tell you, your program simply won't work. And so on.

Typical Assembly Language

Assembly languages are usually unstructured, i.e. there are no control structures such as if or while statements: these have to be manually implemented using labels and jump (goto, branch) instructions. There may exist macros that mimic control structures. The typical look of an assembly program is however still a single column of instructions with arguments, one per line, each representing one machine instruction.

In assembly it is also common to blend program instructions and data, i.e. sometimes you create a label after which you just put bytes that will represent e.g. text strings or images and after that you start to write program instructions that work with these data, which will likely physically be placed this way (after the data) in the final program. This may cause quite nasty bugs if you by mistake jump to a place where data reside and try to treat them as instructions.

The working of the language reflects the actual hardware architecture -- most architectures are based on registers so usually there is a small number (something like 16) of registers which may be called something like R0 to R15, or A, B, C etc. Sometimes registers may even be subdivided (e.g. in x86 there is an eax 32bit register and half of it can be used as the ax 16bit register). These registers are the fastest available memory (faster than the main RAM memory, they are literally INSIDE the CPU, even in front of the cache) and are used to perform calculations. Some registers are general purpose and some are special: typically there will be e.g. the FLAGS register which holds various 1bit results of performed operations (e.g. overflow, zero result etc.). Some instructions may only work with some registers (e.g. there may be kind of a "pointer" register used to hold addresses along with instructions that work with this register, which is meant to implement arrays). Values can be moved between registers and the main memory (with instructions called something like move, load or store).

Writing instructions works similarly to how you call a function in high level language: you write its name and then its arguments, but in assembly things are more complicated because an instruction may for example only allow certain kinds of arguments -- it may e.g. allow a register and immediate constant (kind of a number literal/constant), but not e.g. two registers. You have to read the documentation for each instruction. While in high level language you may write general expressions as arguments (like myFunc(x + 2 * y,myFunc2())), here you can only pass specific values.

There are also no complex data types, assembly only works with numbers of different size, e.g. 16 bit integer, 32 bit integer etc. Strings are just sequences of numbers representing ASCII values, it is up to you whether you implement null terminated strings or Pascal style strings. Pointers are just numbers representing addresses. It is up to you whether you interpret a number as signed or unsigned (some instructions treat numbers as unsigned, some as signed, some don't care because it doesn't matter).

Instructions are typically written as three-letter abbreviations and follow some unwritten naming conventions so that different assembly languages at least look similar. Common instructions found in most assembly languages are for example:

• MOV (move): move a number between registers and/or main memory (RAM).
• JMP (jump, also e.g. BRA for branch): unconditional jump to far away instruction.
• JEQ (jump if equal, also BEQ etc.): jump if result of previous comparison was equality.
• ADD (add): add two numbers.
• NOP (no operation): do nothing (used e.g. for delays or as placeholders).
• CMP (compare): compare two numbers and set relevant flags (typically for a subsequent conditional jump).
• ...

Fun note: HCF -- halt and catch fire -- is a humorous nickname for instructions that just stop the CPU and wait for restart.

How To

For specific assembly language how tos see their own articles: x86, Arm etc.

On Unices the objdump utility from GNU binutils can be used to disassemble compiled programs, i.e view the instructions of the program in assembly (other tools like ndisasm can also be used). Use it e.g. as:

objdump -d my_compiled_program

Let's now write a simple Unix program in 64bit x86 assembly -- we'll be using AT&T syntax that's used by GNU. Write the following source code into a file named e.g. program.s:

.global   _start         # include the symbol in object file

str:
.ascii    "it works\n"   # the string data

.text 
_start:                  # execution starts here
  mov     $5,   %rbx     # store loop counter in rbx

.loop:
  # make a Linux "write" syscall:
                         # args to syscall will be passed in regs.
  mov     $1,   %rax     # says syscalls type (1 = write)
  mov     $1,   %rdi     # says file to write to (1 = stdout)
  mov     $str, %rsi     # says the address of the string to write
  mov     $9,   %rdx     # says how many bytes to write
  syscall                # makes the syscall

  sub     $1,   %rbx     # decrement loop counter
  cmp     $0,   %rbx     # compare it to 0
  jne     .loop          # if not equal, jump to start of the loop

  # make an "exit" syscall to properly terminate:
  mov     $60,  %rax     # says syscall type (60 = exit)
  mov     $0,   %rdi     # says return value (0 = success)
  syscall                # makes the syscall

The program just writes out it works five times: it uses a simple loop and a Unix system call for writing a string to standard output (i.e. it won't work on Windows and similar shit).

Now assembly source code can be manually assembled into executable by running assemblers like as or nasm to obtain the intermediate object file and then linking it with ld, but to assemble the above written code simply we may just use the gcc compiler which does everything for us:

gcc -nostdlib -no-pie -o program program.s

Now we can run the program with

./program

And we should see

it works
it works
it works
it works
it works

As an exercise you can objdump the final executable and see that the output basically matches the original source code. Furthermore try to disassemble some primitive C programs and see how a compiler e.g. makes if statements or functions into assembly.

Example

Let's take the following C code:

#include <stdio.h>

char incrementDigit(char d)
{
  return // remember this is basically an if statement
    d >= '0' && d < '9' ?
    d + 1 :
    '?';
}

int main(void)
{
  char c = getchar();
  putchar(incrementDigit(c));
  return 0;
}

We will now compile it to different assembly languages (you can do this e.g. with gcc -S my_program.c). This assembly will be pretty long as it will contain boilerplate and implementations of getchar and putchar from standard library, but we'll only be looking at the assembly corresponding to the above written code. Also note that the generated assembly will probably differ between compilers, their versions, flags such as optimization level etc. The code will be manually commented.

{ I used this online tool: https://godbolt.org. ~drummyfish }

{ Also not sure the comments are 100% correct, let me know if not. ~drummyfish }

The x86 assembly may look like this (to understand the weird juggling of values between registers see calling conventions):

incrementDigit:
  pushq   %rbp                   # save base pointer
  movq    %rsp, %rbp             # move base pointer to stack top
  movl    %edi, %eax             # move argument to eax
  movb    %al, -4(%rbp)          # and move it to local var.
  cmpb    $47, -4(%rbp)          # compare it to '0'
  jle     .L2                    # if <=, jump to .L2
  cmpb    $56, -4(%rbp)          # else compare to '9'
  jg      .L2                    # if >, jump to .L4
  movzbl  -4(%rbp), %eax         # else get the argument
  addl    $1, %eax               # add 1 to it
  jmp     .L4                    # jump to .L4
.L2:
  movl    $63, %eax              # move '?' to eax (return val.)
.L4:
  popq    %rbp                   # restore base pointer
  ret
  
main:
  pushq   %rbp                   # save base pointer
  movq    %rsp, %rbp             # move base pointer to stack top
  subq    $16, %rsp              # make space on stack
  call    getchar                # push ret. addr. and jump to func.
  movb    %al, -1(%rbp)          # store return val. to local var.
  movsbl  -1(%rbp), %eax         # move with sign extension
  movl    %eax, %edi             # arg. will be passed in edi
  call    incrementDigit
  movsbl  %al, %eax              # sign extend return val.
  movl    %eax, %edi             # pass arg. in edi again
  call    putchar
  movl    $0, %eax               # values are returned in eax
  leave
  ret

The ARM assembly may look like this:

incrementDigit:
  sub   sp, sp, #16              // make room on stack
  strb  w0, [sp, 15]             // load argument from w0 to local var.
  ldrb  w0, [sp, 15]             // load back to w0
  cmp   w0, 47                   // compare to '0'
  bls   .L2                      // branch to .L2 if <
  ldrb  w0, [sp, 15]             // load argument again to w0
  cmp   w0, 56                   // compare to '9'
  bhi   .L2                      // branch to .L2 if >=
  ldrb  w0, [sp, 15]             // load argument again to w0
  add   w0, w0, 1                // add 1 to it
  and   w0, w0, 255              // mask out lowest byte
  b     .L3                      // branch to .L3
.L2:
  mov   w0, 63                   // set w0 (ret. value) to '?'
.L3:
  add   sp, sp, 16               // shift stack pointer back
  ret
  
main:
  stp   x29, x30, [sp, -32]!     // shift stack and store x regs
  mov   x29, sp
  bl    getchar
  strb  w0, [sp, 31]             // store w0 (ret. val.) to local var. 
  ldrb  w0, [sp, 31]             // load it back to w0
  bl    incrementDigit
  and   w0, w0, 255              // mask out lowest byte
  bl    putchar
  mov   w0, 0                    // set ret. val. to 0
  ldp   x29, x30, [sp], 32       // restore x regs
  ret

The RISC-V assembly may look like this:

incrementDigit:
  addi    sp,sp,-32              # shift stack (make room)
  sw      s0,28(sp)              # save frame pointer
  addi    s0,sp,32               # shift frame pointer
  mv      a5,a0                  # get arg. from a0 to a5
  sb      a5,-17(s0)             # save to to local var.
  lbu     a4,-17(s0)             # get it to a4
  li      a5,47                  # load '0' to a4
  bleu    a4,a5,.L2              # branch to .L2 if a4 <= a5
  lbu     a4,-17(s0)             # load arg. again
  li      a5,56                  # load '9' to a5
  bgtu    a4,a5,.L2              # branch to .L2 if a4 > a5
  lbu     a5,-17(s0)             # load arg. again
  addi    a5,a5,1                # add 1 to it
  andi    a5,a5,0xff             # mask out the lowest byte
  j       .L3                    # jump to .L3
.L2:
  li      a5,63                  # load '?'
.L3:
  mv      a0,a5                  # move result to ret. val.
  lw      s0,28(sp)              # restore frame pointer
  addi    sp,sp,32               # pop stack
  jr      ra                     # jump to addr in ra
  
main:
  addi    sp,sp,-32              # shift stack (make room)
  sw      ra,28(sp)              # store ret. addr on stack
  sw      s0,24(sp)              # store stack frame pointer on stack
  addi    s0,sp,32               # shift frame pointer
  call    getchar
  mv      a5,a0                  # copy return val. to a5
  sb      a5,-17(s0)             # move a5 to local var
  lbu     a5,-17(s0)             # load it again to a5
  mv      a0,a5                  # move it to a0 (func. arg.)
  call    incrementDigit
  mv      a5,a0                  # copy return val. to a5
  mv      a0,a5                  # get it back to a0 (func. arg.)
  call    putchar
  li      a5,0                   # load 0 to a5
  mv      a0,a5                  # move it to a0 (ret. val.)
  lw      ra,28(sp)              # restore return addr.
  lw      s0,24(sp)              # restore frame pointer
  addi    sp,sp,32               # pop stack
  jr      ra                     # jump to addr in ra

Assertiveness

Assertiveness is an euphemism for being a dick.

Arcus Tangent

Arcus tangent, written as atan or tan^-1, is the inverse function to the tangent function. For given argument x (any real number) it returns a number y (from -pi/2 to pi/2) such that tan(y) = x.

Approximation: Near 0 atan(x) can very rougly be approximated simply by x. For a large argument atan(x) can be approximated by pi/2 - 1/x (as atan's limit is pi/2). The following formula { created by me ~drummyfish } approximates atan with a poylnomial for non-negative argument with error smaller than 2%:

atan(x) ~= (x * (2.96088 + 4.9348 * x))/(3.2 + 3.88496 * x + pi * x^2)

            | y
       pi/2 +                  
            |       _..---''''''
            |   _.''
            | .'
-----------.+'-+--+--+--+--+--> x
        _.' |0 1  2  3  4  5
     _-'    |
.--''       |
      -pi/2 +
            |

plot of atan(x)

Atheism

"In this moment I am euphoric ..." --some retarded atheist

An atheist is someone who doesn't believe in god or any other similar supernatural beings. An especially annoying kind is the reddit atheist who will DESTROY YOU WITH FACTS AND LOGIC^(TM) while managing to throw around le 42 jokes. These atheists are 14 year old children who think they've discovered the secret of the universe and have to let the whole world know they're atheists who will destroy you with their 200 IQ logic and knowledge of all 10 argument logic fallacies, while in fact they reside at the mount stupid and many times involuntarily appear on other subreddits such as r/iamverysmart and r/cringe. They masturbate to Richard Dawkins, love to read soyentific studiiiiiies about how race has no biological meaning and think that religion is literally Hitler (oh noes, reduction to HITLER has been committed, game over). They love to write or even read the "rational" wiki. They like to pick easy targets such as flatearthers and cyberbully them on YouTube with the power of SCIENCE and their enormously large thesaurus (they will never use a word that's among the 100000 most common English words). They are so cringe you want to kill yourself, but their discussions are sometimes entertaining to read with a bowl of popcorn.

Such a specimen of atheist is one of the best quality examples of a pseudosceptic. See also this: https://www.debunkingskeptics.com/Contents.htm.

On a bit more serious note: we've all been there, most people in their teens think they're literal Einsteins and then later in life cringe back on themselves. However, some don't grow out of it and stay arrogant, ignorant fucks for their whole lives. The principal mistake of the stance they retain is they try to apply "science" (or whatever it means in their world) to EVERYTHING and reject any other approach to solving problems -- of course, science (the real one) is great, but it's just a tool, and just like you can't fix every problem with a hammer, you can't approach every problem with science. In your daily life you make a million of unscientific decisions and it would be bad to try to apply science to them; you cross the street not because you've read a peer-reviewed paper about it being the most scientifically correct thing to do, but because you feel like doing it, because you believe the drivers will stop and won't run you over. Beliefs, intuition, emotion, non-rationality and even spirituality are and have to be part of life, and it's extremely stupid to oppose these concepts just out of principle. With that said, there's nothing wrong about being a well behaved man who just doesn't feel a belief in any god in his heart, just you know, don't be an idiot.

Among the greatest minds it is hard to find true atheists, even though they typically have a personal and not easy to describe faith. Newton was a Christian. Einstein often used the word "God" instead of "nature" or "universe"; even though he said he didn't believe in the traditional personal God, he also said that the laws of physics were like books in a library which must have obviously been written by someone or something we can't comprehend. Nikola Tesla said he was "deeply religious, though not in the orthodox sense". There are also very hardcore religious people such as Larry Wall, the inventor of Perl language, who even planned to be a Christian missionary. The "true atheists" are mostly second grade "scientists" who make career out of the pose and make living by writing books about atheism rather than being scientists.

See Also

• stupidity

Attribution

In the world of intellectual works (such as programs, texts, images etc.) attribution means visibly and properly acknowledging the work of collaborators, i.e. usually mentioning the names or pseudonyms of others that somehow took part in creation of the work. Sometimes we distinguish between merely giving credit, i.e. just recording collaborators somewhere, even in a less visible place such as some documentation file, and proper attribution which may have further conditions, e.g. mentioning the authors in a visible place (e.g. game's main menu) along with a link to their website and so on. Attribution is something that's often a condition of a license, i.e. for example the Creative Commons Attribution (CC BY) license grants everyone rights to the work as long as the original author is properly attributed. However we at LRS see such license requirements as harmful; forcing attribution with a license is a very bad idea! Never do it. Please consider the following:

• Forcing attribution may cause practical problems and make your work unusable. While it's no issue to give proper attribution to one guy who made music for your game, consider also a different scenario: e.g. in development of LMMS, a FOSS music making program, the authors had to collect hundreds of short sound samples for their virtual instruments -- here they couldn't use CC BY-SA samples because doing so would require anyone who made music with their program to also carry on proper attribution of all the author of every single sample that was used in the music, which is practically almost impossible.
• Forcing attribution can make you be force singed under things you don't want to be signed under. Consider you make a comics for children and license it CC BY-SA, i.e. require attribution. By free culture principles someone can take the characters from your story and make porn or terrorist supporting videos with them and even if those guys knew you wouldn't want to be signed under this (because you e.g. made it clear on your blog that you hate porn and terrorism) and even if they would be willing to not name you, your license will force them to write your name PROPERLY, i.e. visibly, under the thing they make.
• You're still playing the copyright game -- even if you relax copyright, you still acknowledge of the idea you keep some basic rights and have to enforce a "correct use" of your work. Even if the difference between CC0 and CC BY was practically of small importance, your mindset will likely be very different with each of them. There is a pattern of people who use CC0 being completely cool while the "CC BY-SA" people oftentimes changing their mind, trying to make trouble with "moral rights" and so on. Just don't do this.
• It is just legal bloat, it created friction, distract artists. It is unnecessary. Even if it's a small burden, it's still a burden for everyone -- the license has to be longer, it has to define what proper attribution means, what happens if it can't be technically achieved etc. You have to keep one more thing in your working memory, you have to observe if people respect this condition etc.
• It discourages many from using your work. For some of the mentioned reasons many people actually avoid reusing works that require attribution { Including me and many other people I know. ~drummyfish }. There exist dangers like attribution getting unintentionally lost in some copy paste by which you start violating the license, people are aware of this danger so they firstly look for works with no conditions at all, just to be safer. By releasing your work without requiring attribution you usually get "extra points" from the free culture community for saving other headaches and trouble.
• You will almost certainly be attributed even if you don't force it. People naturally credit others and there is basically no reason not to, it's in everyone's interest. In practice many people use licenses/waiver that don't force attribution and basically no "abuse" of this is seen -- firstly people are culturally very strongly taught to always attribute others and socially rewarded for doing so, but secondly it doesn't even make any sense to try to come up with any "abuse", there isn't a way to abuse this -- imagine someone wanted to take credit on social media for some work he didn't make: it would sooner or later be found he didn't make the work anyway -- the original author would comment or it would show the guy is incapable of producing more similar works etc., and this can be confirmed on the Internet by digging and finding the work posted previously by someone else. So the guy would just forever mark himself as a scammer, people just don't even try this. AND even if this happens -- e.g. with some nasty copycat Chinese scammers -- they just blatantly "steal" the work no matter the license, they literally don't care about licenses, they steal even proprietary Hollywood movie characters, license doesn't do anything here. { I've been using exclusively CC0 (which doesn't require credit) for many years and literally never encountered a single case when someone wouldn't credit me, nor have I heard of any malicious attempts at abusing this anywhere. ~drummyfish }
• ...

See Also

• copyleft
• NC
• ND

Audiophilia

Audiophilia is a mental disorder, similar to other diseases such as distrohopping and chronic ricing, that makes one scared of low or normal quality audio. Audiophiles are scared of lossy compression and so harm society by wasting storage space. Audiophilia, similarly to e.g. the business with mechanical keyboards, is the astrology of technology, it is an arbitrarily invented bullshit business creating an artificial need that makes people wanna buy golden cables and similar shit in belief that it will make their life happier, perpetuation consumerism and capitalism.

Autostereogram

Autostereogram is a cool sort of image that when viewed in a special way (with eyes crossed or "walled") enables the viewer to see a 3D structure within it by cheating human stereoscopic vision (it is therefore in a sense also an optical illusion). As the name suggests it is a special case of stereogram but unlike many traditional stereograms consisting of two side by side images, autostereogram is only a single image that forms the perceivable 3D pattern by being overlaid with itself (hence the prefix auto). These images are quite awesome for they implement stereoscopic 3D images without the need for special glasses or complex techniques like autostereoscopy or holography -- autostereograms can be made as long as we can draw plain 2D images, but of course they also suffer from some limitations. There are several types of autostereograms.

Viewing autostereograms is easy for some and difficult for others but don't worry, it can be trained. One trick that's used (for the "cross eyed" types of images) is putting a finger in front of the image, focusing your sight on it and then lowering the finger while keeping your eyes looking at the point where the finger was (for "walled" images you have to be looking beyond the image, i.e. try looking at a wall behind it). Also be careful about the possibility of crossing your eyes "too much" and seeing the image in incorrect way. Once you see the pattern, keep looking at it for a longer time, it becomes clearer and clear as the brain makes out more of the structure (it may also help to slightly move your head from side to side).

TODO

Random Dot Autostereograms

The "random dot" technique gives rise to an especially interesting type of autostereogram -- one whose creation can easily be automatized with a program and which lets us embed any depth image (or heightmap) into an image that consists of some repeating base pattern. And yes, it can even be animated! The pattern image may in theory be anything, even a photo, but it should have great variety, high frequencies and big contrast to work properly, so the typical pattern is just randomly generated color dots. This pattern is then horizontally deformed according to the embedded depth image. A disadvantage is, of course, that we can only embed the depth image, we cannot give it any texture.

TODO: more detail

 .:,oX#r-'/=*miQ .:,oX#r-'/=*miQ .:,oX#r-'/=*miQ .:,oX#r-'/=*miQ .:,oX#r-'/=*miQ .:,oX#r-'/=*miQ
miQ)35;_0p]w@x4EmiQ)35;_0p]w@x4EmiQ)35;_0p]w@x4EmiQ)35;_0p]w@x4EmiQ)35;_0p]w@x4EmiQ)35;_0p]w@x4E
x4EY!{ .:,oX#r-'x4EY!{ .:,oX#r-'x4EY!{ .:,oX#r-'x4EY!{ .:,oX#r-'x4EY!{ .:,oX#r-'x4EY!{ .:,oX#r-'
r-'/=*miQ)35;_0pr'/=*miQ)35;_00pr'/=*miQ)35;_00pr'/=*miQ)35;_00pr'/=*miQ)35;_00pr'/=*miQ)35;_00p
_0p]w@x4EY!{ .:,_0]w@x4EY!{ ..:,_0]w@x4EY!..:,_0]w@x4EY!..:.:,_0]w@x4EY!..:.:,_0]w@x4EY!..:.:,_0
.:,oX#r-'/=*miQ).:,o#r-'/=**miQ).:,o#r-'/=*iQ).:,o#r-'/=*iQ).).:,o#r-'/=*iQ.).:,o#r-''/=*iQ).).:
iQ)35;_0p]w@x4EYiQ)3;_0p]w@@x4EYiQ)3;_0p]w@@EYiQ)3;3;_0w@@EYiQiQ)3;3;_0w@EYiQiQ)3;3;_0w@@EYYiQiQ
4EY!{ .:,oX#r-'/4EY! .:,oX##r-'/4EY! .:,oX##'/4EY! ! .:,##'/4E4EY! ! .,##'/4E44EY!  .,##''//4E4E
-'/=*miQ)35;_0p]-'/=miQ)35;;_0p]-'/=miQ)35;;p]-'/=m=miQ);;p]-'-'/=m=mi);;p]-''-'/=m=i);;p]]]-'-'
0p]w@x4EY!{ .:,o0p]wx4EY!{  .:,o0p]wx4EY!{  ,o0p]wxwx4!{  ,o0o0p]wxwx4{  ,o0o00p]wxwx4{  ,oo0o0p
:,oX#r-'/=*miQ)3:,oXr-'/=*mmiQ)3:,oXr-'/=*mm)3:,oXr-'/=*mm)3)3:,oXr-'/=*m)3)3:,oXr-''/=*m)33)3:,
Q)35;_0p]w@x4EY!Q)35_0p]w@xx4EY!Q)350pp]w@xxY!Q)350pp]w@xxY!Y!Q)350pp]w@xxY!!Q)350pp]w@xxxY!Y!Q)
EY!{ .:,oX#r-'/=EY!{.:,oX#rr-'/=EY!{:,,oX#rr/=EY!{:{:,,#rr/=E=EY!{:{:,,#rr/=E=EY{:{:,,#rrr/=E=EY
'/=*miQ)35;_0p]w'/=*iQ)35;__0p]w'/*iQ))35;__]w'/*iQiQ))3__]w'/'/*iQi))3__]ww'/'/*ii))3__]www'/'/
p]w@x4EY!{ .:,oXp]wx4EY!{ .:,oXp]wx4EYY!{ .:Xpp]x4E4EYY!{:Xpp]]]x4E4YY!{:Xppp]]]x4EYY!{:Xpppp]]]
,oX#r-'/=*miQ)35,o#r-'/=*miQ)35,o#r-'//=*miQ5,,or-'/'//=*Q5,,oo#r-'/'/=*Q5,,ooo#r-/'/=*Q5,,,,oo#
)35;_0p]w@x4EY!{)35;_0p]w@x4EY!{)35;_0p]w@xY!{)35;_0p0p]wY!{)3)3_;_0p0]wY!{)3)35;_0p0]wY!!{{)3)3
Y!{ .:,oX#r-'/=*Y!{ .:,oX#r-'/=*Y!{ .:,oX#r-'/=*Y!{ .:,oX#r-'/=*Y!{ .:,oXr-'/=*Y!{ .:,,oXr--'/=*
/=*miQ)35;_0p]w@/=*miQ)35;_0p]w@/=*miQ)35;_0p]w@/=*miQ)35;_0p]w@/=*miQ)35;_0p]w@/=*miQ)35;_0p]w@
]w@x4EY!{ .:,oX#]w@x4EY!{ .:,oX#]w@x4EY!{ .:,oX#]w@x4EY!{ .:,oX#]w@x4EY!{ .:,oX#]w@x4EY!{ .:,oX#

If you look at this image the correct way, you'll see a 3D image of big letters spelling out LRS. Please forgive an increased viewing difficulty of ASCII art as compared to a true bitmap image.

The following is a C program that generates the above image.

#include <stdio.h>

#define PATTERN_SIZE 16
#define RES_X 75
#define RES_Y 20
#define PATTERN_SEED_SIZE 32

char patternSeed[PATTERN_SEED_SIZE] = " .:,oX#r-'/=*miQ)35;_0p]w@x4EY!{";

char depth[RES_X * RES_Y + 1] = // must be big and simple to be easily seen
  "                                                                           "  
  "                                                                           "  
  "                                                                           "  
  " 1111111111111                                                             "
  "  11111111111             22222222222222222                                "  
  "    1111111                222222222222222222              1111111111      "  
  "    1111111                 2222222    2222222          1111111111111111   "  
  "    1111111                 2222222     222222        11111111     111111  "  
  "    1111111                 2222222     222222        1111111       111111 "  
  "    1111111                 2222222   2222222         11111111             "  
  "    1111111                 2222222222222222            111111111111       "  
  "    1111111         11      2222222222222222                111111111111   "  
  "    1111111         11      2222222    222222                   111111111  "  
  "    1111111       1111      2222222     222222      1111111       11111111 "  
  "   1111111111111111111      2222222      222222     1111111        1111111 "  
  "  11111111111111111111      22222222     2222222     11111111     11111111 "  
  "                           2222222222    22222222     1111111111111111111  "  
  "                                                         1111111111111     "  
  "                                                                           "  
  "                                                                           ";

char buffer1[PATTERN_SIZE + 1];
char buffer2[PATTERN_SIZE + 1];

int charToDepth(char c)
{
  return c == ' ' ? 0 : (c - '0');
}

int main(void)
{
  const char *c = depth;
  char *lineCurrent, *linePrev;

  buffer1[PATTERN_SIZE] = 0;
  buffer2[PATTERN_SIZE] = 0;
 
  for (int j = 0; j < RES_Y; ++j)
  {
    for (int i = 0; i < PATTERN_SIZE; ++i) // initiate first pattern from seed
      buffer1[i] =  patternSeed[(i + (j * 13)) % PATTERN_SEED_SIZE];

    lineCurrent = buffer1;
    linePrev = buffer2;

    for (int i = 0; i < RES_X; ++i)
    {
      if (i % PATTERN_SIZE == 0)
      {
        printf("%s",lineCurrent); // print the rendered line
        
        char *tmp = lineCurrent;  // swap previous and current buffer
        lineCurrent = linePrev;
        linePrev = tmp; 
      }

     lineCurrent[i % PATTERN_SIZE] = // draw the offset pixel
       linePrev[(PATTERN_SIZE + i + charToDepth(*c)) % PATTERN_SIZE];

      c++;
    }

    printf("%s\n",lineCurrent); // print also the last buffer
  }

  return 0;
}

Autoupdate

Autoupdate is a malicious software feature that frequently remotely modifies software on the user's device without asking, sometimes silently and many times in a forced manner without the possibility to refuse this modification (typically in proprietary software). This is a manifestation of update culture. These remote software modifications are called "updates" to make the user think they are a good thing, but in fact they usually introduce more bugs, bloat, security vulnerabilities, annoyance (forced reboots etc.) and malware (even in "open source", see e.g. the many projects on GitHub that introduced intentional malware targeted at Russian users during the Russia-Ukraine war).

Avoidant Personality Disorder

Avoiding the problem is in majority of cases the best solution to the problem.

Avoidant Personality Disorder (AVPD) is one of the great myriad of psychological personality "disorders" that's basically characterized by extreme shyness, social isolation and tendency to solve everything by avoidance -- people with this thing have no friends, social life, they isolate, don't go out, don't go to work (that's good), they constantly think about how they're judged by others, may try to adjust personality according to what the other people around seem to want etc. It could possibly be seen as the hardcore minimalist disease, AVPD positives just minimize their life to the a bare minimum of things they can't avoid, like eating, breathing etc. Of course this goes with anxiety, panic attacks and depression, sometimes self harm and so on.

Axiom Of Choice

In mathematics (specifically set theory) axiom of choice is a possible axiom which basically states we can arbitrarily choose elements of sets and which is famous for being controversial and problematic because it causes trouble both when we accept or reject it. Now it's actually been included in ZFC, a kind of "commonly used base for mathematics", but its controversial nature stands. Note that this topic can go to a great depth and lead to philosophical debates, there is a huge rabbit hole and mathematicians can talk about this for hours; here we'll only state the very basic and quite simplified things, mostly for those who aren't professional mathematicians but need some overview of mathematics (e.g. programmers).

Indeed, what really IS the axiom of choice? It is an axiom, i.e. something that we can't prove but can either accept or reject as a basic fact so that we can use it to prove things. Informally it says that given any collection of sets (even an infinite collection of infinitely large sets), we can make an arbitrary selection of one element from each set. More mathematically it says: if we have a collection of sets, there always exists a function f such that for any set S from the collection f(S) is an element of S.

This doesn't sound weird, does it? Well, in many normal situations it isn't. For example if we have finitely many sets, we can simply write out each element of the set, we don't need to define any selection function, so we don't need axiom of choice to make our choice of elements here. But also if we have infinitely many sets that are well ordered (we can compare elements), for example infinitely many sets of natural numbers, we can simply define a function that takes e.g. the smallest number from each set -- here we don't need axiom of choice either. The issues start if we have e.g. infinitely many sets of real numbers (which can't be well ordered without the axiom of choice, consider that e.g. open intervals don't have lowest number) -- here we can't say how a function should select one element from each set, so we have to either accept axiom of choice (we say it simply can be done "somehow", e.g. by writing each element out on an infinitely large paper) or reject it (we say it can't be done). Here it is again the case that what's normally completely non-problematic starts to get very weird once you involve infinity.

Why is it problematic? Once you learn about axiom of choice, your first question will probably be why should it pose any problems if it just seems like an obvious fact. Well, it turns out it leads to strange things. If we accept axiom of choice, then some weird things happen, most famously e.g. the Banach-Tarski paradox which uses the axiom of choice to prove that you can disassemble a sphere into finitely many pieces, then move and rotate them so that they create TWO new spheres, each one identical to the original (i.e. you duplicate the original sphere). But if we reject the axiom of choice, other weird things happen, for example we can't prove that every vector space has a basis -- it seems quite elementary that every vector space should have a basis, but this can't be proven without the axiom of choice and in fact accepting this implies the axiom of choice is true. Besides this great many number of proofs simply don't work without axiom of choice. So essentially either way things get weird, whether we accept axiom of choice or not.

So what do mathematicians do? How do they deal with this and why don't they kill themselves? Well, in reality most of them are pretty chill and don't really care, they try avoid it if they can (their proof is kind of stronger if it relies on fewer axioms) but they accept it if they really need it for a specific proof. Many elementary things in mathematics actually rely on axiom of choice, so there's no fuss when someone uses it, it's very normal. Turns out axiom of choice is more of something they argue over a beer, they usually disagree about whether it is INTUITIVELY true or false, but that doesn't really affect their work.

Backgammon

Backgammon is an old, very popular board game of both skill and chance (dice rolling) in which players race their stones from one side of the board to the other. It often involves betting (but can also be played without it) and is especially popular in countries of Near East such as Egypt, Syria etc. (where it is kind of what chess is to our western world or what shogi and go are to Asia). It is a very old game whose predecessors were played by old Romans and can be traced even as far as 3000 BC. Similarly to chess, go, shogi and other traditional board games backgammon is considered by us to be one of the best games as it is owned by no one, highly free, cheap, simple yet deep and entertaining and can be played even without a computer, just with a bunch of rocks; compared to the other mentioned board games backgammon is unique by involving an element of chance and being only played on 1 dimensional board; it is also relatively simple and therefore noob-friendly and possibly more relaxed (if you lose you can just blame it on rolling bad numbers).

Rules

Here we'll summarize the common rules, keep in mind there may be some variations, like extra rules on competitive level and so on. The rules seem quite complex and arbitrary at first, but by playing you'll see they're really pretty simple and sometimes quite intuitive (furthermore the game, at least on casual level, mostly doesn't require such hard thinking as e.g. chess, so it even feels more relaxed, you can focus on the rules well).

There are two players, black and white, each moving circular stone discs, or just stones of his color, here we'll use {# for black stones and (O for white ones. There are two six sided dice in the game. The board has 24 places (vertical lines, traditionally drawn as long triangles) which stones can occupy. The following shows the board, the initial setup of stones, the directions in which players move and their goals.

   black's direction
 .------------ - -  -  -
 |   ___________________________
 |  |{# ; ; ;(O ; |(O ; ; ; ;{# | white's goal
 |  |{# : : :(O : |(O : : : :{# |
 |  |{# . . .(O . |(O . . . . . |
 V  |{# . . . . . |(O . . . . . |
    |{#           |(O           |
    |             |             |
    |(O           |{#           |
 ^  |(O . . . . . |{# . . . . . |
 |  |(O . . .{# . |{# . . . . . |
 |  |(O : : :{# : |{# : : : ;(O |
 |  |(O ; ; ;{# ; |{# ; ; ; ;(O | black's goal
 |   """""""""""""""""""""""""""
 '------------ - -  -  -
   white's direction

The goal of each player is to get all his stones to his goal -- the goal is one place beyond the last place on the board in the direction of his movement. Whoever does this the first wins.

The first six places on one's path are called the home board, the last six are called the outer board.

At start both players roll the dice (each one rolls one), whoever rolls the bigger number starts and has to use (details below) the numbers that were just rolled for his first turn (if the numbers were the same, they roll again). After the first player finishes his round, the other player rolls both dice, makes his turn, then the first player does the same again and so on, the players just take turns in rolling dice and playing.

A turn is played by rolling the two dice, resulting in numbers X (one die) and Y (the other one). The player then moves two stones (he can choose which), one by X places, the other by Y places. He can also move the same stone, but the move still counts as moving twice, i.e. first moving the stone by X, then moving it again by Y, or vice versa (this may be important in regards to rules explained later). If X and Y are the same, the numbers are doubled, so the player gets 4 numbers to play: X, X, X, X -- for example rolling 2 and 2, the player can move 4 stones, each by 2, or 1 stone by 8 (in separate steps) or 1 stone by 2 and other one by 6 and so on. Moves cannot be skipped by choice, the player has to move "as much as he can", i.e. if he can at least partially use the numbers he rolled, he has to (also if there is a choice between higher and lower number rolled, he has to use the higher number etc.).

Movement: players move their stones in opposite directions by the number of steps they roll, in a kind of horseshoe shaped path (as shown above -- topologically the board is just a 1D line, it's just curved to nicely fill the board) -- notice that on one end the stones jump from one side of the board to the other side. Stones can walk over stones of same color and can even stay on the same place -- if more than one stones occupy the same place, they are "stacked" and protected against being taken. A stone can move over enemy stones (even if multiple stacked enemy stones), but can end on such place only if there is exactly one enemy stone, in which case it is taken -- it is removed and placed in the middle of the board. Remember that a stone that is moving by a sum of rolled numbers counts as several discrete moves, so if a stone is moving e.g. by 3 + 3 steps, it's not the same as moving by 6 because after the first 3 steps taken it mustn't land on stacked enemy stones (but it can land on one enemy stone and take it).

A stone that's been taken (placed in the middle of the board) is seen as being one place before the player's starting place (the opposite of one's goal), and can be returned to the game (appearing in the enemy home board) -- in fact it HAS TO be returned to the game before any other move can be made by the player whose stone it is, i.e. if a player has any stones out of the game because the opponent has taken them, he cannot move any other stones until he returns all his stones back to the game.

Once the player has all his stones in the enemy home board, he can start bearing off, i.e. getting the stones to the goal (i.e. before this his stones aren't allowed to reach the goal). The goal is seen as a place one after the final board square in the direction of the player's movement -- if the stone gets to the goal, it is placed on the board border. Here there are a bit more complex rules: normally a stone may reach the goal only if it steps on it exactly, i.e. a stone on the very last place can only get to the goal by rolling 1, the stone before it by rolling 2 etc. However the stone furthest away from the goal may also use a value higher than this, i.e. if there is a stone 3 places before the goal AND it is the last one back, it may finish with 3, 4, 5 or 6. During bearing off the player may also use the lower rolled value first, even if it wouldn't fully utilize the higher value (exception to a rule mentioned above).

Details

Despite chance playing some role, skill is highly important and there exist strategies and tactics that maximize once chance of winning -- for example a basic realization is that the different sums you may roll don't have the same probabilities, e.g. 8 can be achieved by 2 + 6 or 2 + 2 + 2 + 2, but 3 only as 2 + 1 -- one can account for this. The highest probability to take the enemy stone with one's own stone is when the stones are 6 places apart. Taking enemy stone while having own stones stacked in all places in enemy home board makes opponent unable to play (he is required to return the stone to play but there is no number that can do it for him). There is also some opening theory.

The game is internationally governed by WBGF (World Backgammon Federation), similarly to how chess is governed by FIDE.

Who was the best player ever? There doesn't seem to be a clear consensus, but Masayuki Mochizuki (Japan) seems to come up very often as an answer to the question, other names include Paul Magriel, Nack Ballard etc.

Backgammon was the first board game in which the world champion at the time (Luigi Villa) was defeated by computer -- this happened in 1979. This was perhaps thanks to the element of chance.

As for backgammon computer engines the best free as in freedom one seems to be GNU backgammon, using neural networks, apparently beyond the strength of best human players. The Extreme Gammon engine is probably a bit stronger (currently said to be the strongest) but it is proprietary and therefore unusable.

Some statistics about the game: there are 18528584051601162496 legal positions. Average branching factor (considering all possible dice rolls) is very high, somewhere around 400, which is likely why space search isn't as effective as in chess and why neural networks greatly prevail. Average number of moves in a game seem to be slightly above 20.

TODO

Backpropagation

{ Dunno if this is completely correct, I'm learning this as I'm writing it. There may be errors. ~drummyfish }

Backpropagation, or backprop, is an algorithm, based on the chain rule of derivation, used in training neural networks; it computes the partial derivative (or gradient) of the function of the network's error so that we can perform a gradient descent, i.e. update the weights towards lowering the network's error. It computes the analytical derivative (theoretically you could estimate a derivative numerically, but that's not so accurate and can be too computationally expensive). Backpropagation is one of the most common methods for training neural networks but it is NOT the only possible one -- there are many more such as evolutionary programming. It is called backpropagation because it works backwards and propagates the error from the output towards the input, due to how the chain rule works, and it's efficient by reusing already computed values.

Details

Consider the following neural network:

     w000     w100
  x0------y0------z0
    \    /  \    /  \
     \  /    \  /    \
      \/w010  \/w11O  \_E
      /\w001  /\w1O1  /
     /  \    /  \    /
    /    \  /    \  /
  x1------y1------z1
     w011     w111

It has an input layer (neurons x0, x1), a hidden layer (neurons y0, y1) and an output layer (neurons z0, z1). For simplicity there are no biases (biases can easily be added as input neurons that are always on). At the end there is a total error E computed from the networks's output against the desired output (training data).

Let's say the total error is computed as the squared error: E = squared_error(z0) + squared_error(z1) = 1/2 * (z0 - z0_desired)^2 + 1/2 * (z1 - z1_desired)^2.

We can see each non-input neuron as a function. E.g. the neuron z0 is a function z0(x) = z0(a(z0s(x))) where:

• z0s is the sum of inputs to the neuron, in this case z0s(x) = w100 * y0(x) + +110 * y1(x)
• a is the activation function, let's suppose the normally used logistic function a(x) = 1/(1 + e^x).

If you don't know what the fuck is going on see neural networks first.

What is our goal now? To find the partial derivative of the whole network's total error function (at the current point defined by the weights), or in other words the gradient at the current point. I.e. from the point of view of the total error (which is just a number output by this system), the network is a function of 8 variables (weights w000, w001, ...) and we want to find a derivative of this function in respect to each of these variables (that's what a partial derivative is) at the current point (i.e. with current values of the weights). This will, for each of these variables, tell us how much (at what rate and in which direction) the total error changes if we change that variable by certain amount. Why do we need to know this? So that we can do a gradient descent, i.e. this information is kind of a direction in which we want to move (change the weights and biases) towards lowering the total error (making the network compute results which are closer to the training data). So all in all the goal is to find derivatives (just numbers, slopes) with respect to w000, w001, w010, ... w111.

Could we do this without backpropagation? Yes -- we can use numerical algorithms to estimate derivatives, the simplest one would be to just try to change each weight, one by one, by some small number, let's say dw, and see how much such change changes the output error. I.e. we would sample the error function in all directions which could give us an idea of the slope in each direction. However this would be pretty slow, we would have to reevaluate the whole neural network as many times as there are weights. Backpropagation can do this much more efficiently.

Backpropagation is based on the chain rule, a rule of derivation that equates the derivative of a function composition (functions inside other functions) to a product of derivatives. This is important because by converting the derivatives to a product we will be able to reuse the individual factors and so compute very efficiently and quickly.

Let's write derivative of f(x) with respect to x as D{f(x),x}. The chain rule says that:

D{f(g(x)),x} = D{f(g(x)),g(x)} * D{g(x),x}

Notice that this can be applied to any number of composed functions, the product chain just becomes longer.

Let's get to the computation. Backpropagation work by going "backwards" from the output towards the input. So, let's start by computing the derivative against the weight w100. It will be a specific number; let's call it 'w100. Derivative of a sum is equal to the sum of derivatives:

'w100 = D{E,w100} = D{squared_error(z0),w100} + D{squared_error(z0),w100} = D{squared_error(z0),w100} + 0

(The second part of this sum became 0 because with respect to w100 it is a constant.)

Now we can continue and utilize the chain rule:

'w100 = D{E,w100} = D{squared_error(z0),w100} = D{squared_error(z0(a(z0s))),w100} = D(squared_error(z0),z0) * D{a(z0s),z0s} * d{z0s,w100}

We'll now skip the intermediate steps, they should be easy if you can do derivatives. The final results is:

'w100 = (z0_desired - z0) * (z0s * (1 - z0s)) * y0

Now we have computed the derivative against w100. In the same way can compute 'w101, 'w110 and 'w111 (weights leading to the output layer).

Now let's compute the derivative in respect to w000, i.e. the number 'w000. We will proceed similarly but the computation will be different because the weight w000 affects both output neurons ('z0' and 'z1'). Again, we'll use the chain rule.

w000 = D{E,w000} = D(E,y0) * D{a(y0s),y0s} * D{y0s,w000}

D(E,y0) = D{squared_error(z0),y0} + D{squared_error(z1),y0}

Let's compute the first part of the sum:

D{squared_error(z0),y0} = D{squared_error(z0),z0s} * D{squared_error(z0s),y0}

D{squared_error(z0),z0s} = D{squared_error(z0),z0} * D{a(z0s)),z0s}

Note that this last equation uses already computed values which we can reuse. Finally:

D{squared_error(z0s),y0} = D{squared_error(w100 * y0 + w110 * y1),y0} = w100

And we get:

D{squared_error(z0),y0} = D{squared_error(z0),z0} * D{a(z0s)),z0s} * w100

And so on until we get all the derivatives.

Once we have them, we multiply them all by some value (learning rate, a distance by which we move in the computed direction) and subtract them from the current weights by which we perform the gradient descent and lower the total error.

Note that here we've only used one training sample, i.e. the error E was computed from the network against a single desired output. If more example are used in a single update step, they are usually somehow averaged.

Bazaar (The Cathedral And The Bazaar)

The Cathedral and the Bazaar (shortened to catb) is a very famous software engineering paper from 1997 by Eric S. Raymond (ESR, a famous oldschool hacker writer) which analyzes the development method of Linux, at the time a new way of mass developing FOSS software by many volunteers over the Internet with relatively little central planning -- this method is called the Bazaar (the word used for marketplace in middle east) and is contrasted with so called Cathedral method, i.e. the traditional, highly centralized development of software (not necessarily of proprietary software). This essay was later being expanded, updated and made into a whole book -- the short version of it can be read on ESR's website. It played a role in corporations adopting "open source" (Netscape, i.e. Firefox, was "open sourced" basically because of this essay).

Watch out: Raymond used to be an oldschool hacker who however, like many others, later turned to the evil side once he smelled money and fame; he basically became hardcore capitalist, promoting open $ource, free markets and even doing business himself. It can very well be seen in the essay -- it's not about programming, it is about software engineering, i.e. managing and manipulating masses of people to work like machines who will be continuously producing lines of code. It focused on things such as "productivity" and basically how to develop bloat in fastest way and for least cost. It takes things such as update culture, rapid development, gigantic software projects and existence of software companies for granted. Therefore The Cathedral and the Bazaar is of no use to less retarded software but it may be good to read for the big picture view.

{ The online version is not very long, the writing style is good and there are nice, catchy observations about software development, however it's still quite shitty, towards the end I was falling asleep, only the capitalist trigger words kept me awake eventually. But there are some nice things, like "plan to throw one away", i.e. when you want to write something, you'll probably have to write it once badly, by which you really understand the issue, then you throw it away and implement it again, this time well. ~drummyfish }

Here is a small summary: ESR used to believe software beyond some complexity threshold (e.g. operating system kernel or a big text editor) has to be developed mainly by a small team that closely communicates, carefully fixes bugs that users report and releases stable versions once in relatively long time -- yes, even if the software is FOSS and development is transparent. This is called the Cathedral method as the development is similar to the careful, highly centrally planned building of a cathedral -- one example was e.g. gcc (and any proprietary software, as they basically have no other option). However after seeing Linux (a very complex project) being developed by great many people in a very decentralized manner, with the central coordinator doing relatively little work, and having very short release cycles (even of buggy, unstable versions), he concluded it can work differently -- he called this the Bazaar method, i.e. one that looks a bit chaotic at first, but which statistically still converges to establishing good design in the end. He says the biggest invention of Linus Torvalds isn't Linux but its development model. He examines how and why it works because he sees it as the superior method, and he also tests the method on his own project (fetchmail) with which he immediately sees a great success. He notes several things, e.g. the following. Users being at the same time programmers (codevelopers) and vice versa is key because firstly programmers really care about what they write (because they use it) and secondly we get nice bug reports (in programmer terms). "Given enough eyeballs, all bugs are shallow" (Linus's law) says that with many users/programmers basically all bugs get spotted and fixed quickly, which is helped by the rapid release cycles -- if someone fixes it quickly, others see it's fixed and stop working on their more complicated fixes. This kind of parallelizes debugging (and also other things such as design change exploration). Quick releases reward contributors, they see their fixes immediately, contributors get motivated ("Treat your testers as your most valuable resource and they will respond by becoming your most valuable resource."), even the "work no one wants to do" gets done. Bazaar project needs several things. Firstly good Internet (that's why Linux coincided with cheap access to Internet). Secondly it can't be started from scratch, someone has to make some basic project basically alone, and it should be some truly honest project (not something that just aims for profit), usually starting with a programmer "scratching his own itch" -- it's enough to make a project that shows promise so that people start jumping in. The "leader" doesn't have to be genius but he has to be able to recognize good design choices of contributors and he must be "good with people". Then he goes on to compare it to free market and other crap, he basically concludes managers are useless and they just pretend to be useful :D

BBS

{ I am too young to remember this shit so I'm just writing what I've read on the web. ~drummyfish }

Bulletin board system (BBS) is, or rather used to be, a kind of server that hosts a community of users who connect to it via terminal, who exchange messages, files, play games and otherwise interact -- BBSes were mainly popular before the invention of web, i.e. from about 1978 to mid 1990s, however some still exist today. BBSes are powered by special BBS software and the people who run them are called sysops.

Back then people connected to BBSes via dial-up modems and connecting was much more complicated than connecting to a server today: you had to literally dial the number of the BBS and you could only connect if the BBS had a free line (for zoomers: mobile phones were hardly a thing, every home had a land-line, a physical wire for phone). Early BBSes weren't normally connected through Internet but rather through other networks like UUCP working through phone lines. I.e. a BBS would have a certain number of modems that defined how many people could connect at once. It was also expensive to make calls into other countries so BBSes were more of a local thing, people would connect to their local BBSes. Furthermore these things ran often on non-multitasking systems like DOS so allowing multiple users meant the need for having multiple computers. The boomers who used BBSes talk about great adventure and a sense of intimacy, connecting to a BBS meant the sysop would see you connecting, he might start chatting with you etc. Nowadays the few existing BBSes use protocols such as telnet, nevertheless there are apparently about 20 known dial-up ones in north America. Some BBSes evolved into more modern communities based e.g. on public access Unix systems -- for example SDF.

A BBS was usually focused on a certain topic such as technology, fantasy roleplay, dating, warez etc., they would typically greet the users with a custom themed ANSI art welcome page upon login -- it was pretty cool. BBSes were used to share plain text files of all sorts, be it shareware versions of games, anarchist writings, computer manuals, poetry or recipes. It really was a HUGE thing, you can dig up a lot of fun and obscure material by searching for BBS stuff -- http://textfiles.com is one place that gathers tons and tons of plain text files that were shared on these networks; searching and downloading files was just one favorite activity and obsession of BSS users (there is a very funny text "confession" of a chronic BBS downloader called dljunkie.txt, look that up, it's funny as hell).

{ There's some documentary on BBS that's upposed to give you an insight into this shit, called literally BBS: The documentary. It's about 5 hours long tho. ~drummyfish }

Considerable part of BBS community frowned upon anonymity (see e.g. http://textfiles.com/law/ethics.txt), a rule of some BBSes was that you had to use your real life info like name and address to communicate with others, some even advised against using handles. You met real, non-hiding humans back then, not some anonymous furry they/thems faggot who is scared to even tell you what continent he lives on. Of course, no one probably even considered any encrypted connection back then. This show that today's privacy hysteria is a bullshit, it's sad that today you'll see the exact opposite -- sites that PROHIBIT use of real life credentials. The world is fucked up now.

The first BBS was CBBS (computerized bulletin board system) created by Ward Christensen and Randy Suess in 1978 during a blizzard storm -- it was pretty primitive, e.g. it only allowed one user to be connected at the time. The ideas evolved from those of time sharing computers such as those running Unix, BBS just tried to make them more "user friendly" and so bring in more public to where there were mostly just professionals before, kind of an ancient Facebook-like mini revolution. After publication of their invention, BBSes became quite popular and the number of them grew to many thousands -- later there was even a magazine solely focused on BBSes (BBS Magazine). BBSes would later group into larger networks that allowed e.g. interchange of mail. The biggest such network was FidoNet which at its peak hosted about 35000 nodes.

{ Found some list of BBSes at http://www.synchro.net/sbbslist.html. ~drummyfish }

See Also

• public access Unix
• Usenet
• modem world
• tildeverse
• multi user dungeon
• imageboard
• textboard
• SDF
• FidoNet

Beauty

Beauty is the quality of being extremely appealing and pleasing. Though the word will likely invoke association with traditional art, in technology, engineering, mathematics and other science beauty is, despite it's relative vagueness and subjectivity, an important aspect of design, and in fact this "mathematical beauty" has lots of times some clearly defined shapes -- for example simplicity is mostly considered beautiful. Beauty is similar to and many times synonymous with elegance.

Beauty can perhaps be seen as a heuristic, a touch of intuition that guides the expert in exploration of previously unknown fields, as we have come to learn that the greatest discoveries tend to be very beautiful (however there is also an opposite side: some people, such as Sabine Hossenfelder, criticize e.g. the pursuit of beautiful theories in modern physics as this approach seems to be have led to stagnation). Indeed, beginners and noobs are mostly concerned with learning hard facts, learning standards and getting familiar with already known ways of solving known problems, they often aren't able to recognize what's beautiful and what's ugly. But as one gets more and more experienced and finds himself near the borders of current knowledge, there is suddenly no guidance but intuition, beauty, to suggest ways forward, and here one starts to get the feel for beauty. At this point the field, even if highly exact and rigorous, has become an art.

What is beautiful then? As stated, there is a lot of subjectivity, but generally the following attributes are correlated with beauty:

• simplicity/minimalism, typically finding simplicity in complexity, e.g. a very short formula or algorithm that describes an infinitely complex fractal shape, a simple but valuable equation in physics (e = m * c^2), a short computer program that yields rich results (demoscene, code golfing, suckless, minimal viable program, ...).
• deepness -- if something starting very simple, e.g. a single small equation, leads to consequences that may be studied for millennia, for example prime numbers.
• generality, i.e. if a simple equation can describe many problems, not just a specific case.
• lack of exceptions, i.e. when our equation works without having to deal with special cases (in programming represented by if-then branches).
• symmetry, i.e. when we can e.g. swap variables in the equation and get some kind of opposite result.
• unification, i.e. if multiple nice things meet, for example the Euler's identity brings together into one equation the most important numbers in mathematics: i, pi, 1 and 0.
• aesthetics, either of the equation itself or the generated thing (fractals, attractors, ...).
• TODO

Examples of beautiful things include:

• Euler's identity, an equation often cited as the most beautiful in mathematics: e^{ipi} + 1 = 0*. It is simple and contains many of the most important numbers: e, pi, i 1 and 0.
• minimalist software, Unix philosophy
• fractals TODO
• bytebeat

Bilinear Interpolation

Bilinear interpolation (also bilinear filtering) is a simple way of creating a smooth transition (interpolation) between discrete samples (values) in 2D, it is a generalization of linear interpolation to 2 dimensions. It is used in many places, popularly e.g. in 3D computer graphics for texture filtering; bilinear interpolation allows to upscale textures to higher resolutions (i.e. compute new pixels between existing pixels) while keeping their look smooth and "non-blocky" (even though blurry). On the scale of quality vs simplicity it is kind of a middle way between a simpler nearest neighbour interpolation (which creates the "blocky" look) and more complex bicubic interpolation (which uses yet smoother curves but also requires more samples). Bilinear interpolation can further be generalized to trilinear interpolation (in computer graphics trilinear interpolation is used to also additionally interpolate between different levels of a texture's mipamap) and perhaps even bilinear extrapolation. Many frameworks/libraries/engines have bilinear filtering built-in (e.g. GL_LINEAR in OpenGL). Of course this method may be used to smooth not just textures but anything, for example terrain heightmaps or just any discrete mathematical function that we simply want to have defined everywhere, it's not just graphics thing, but here we will focus on its application in graphics.

####OOOOVVVVaaaaxxxxssssffffllllcccc////!!!!;;;;,,,,....----    
####OOOOVVVVaaaaxxxxxssssffffllllcccc////!!!!;;;;,,,,.....----  
####OOOOVVVVaaaaaxxxxssssfffflllllcccc////!!!!!;;;;,,,,....-----
###OOOOOVVVVaaaaaxxxxsssssfffflllllcccc////!!!!!;;;;,,,,,....---
###OOOOVVVVVaaaaaxxxxsssssfffffllllccccc/////!!!!!;;;;,,,,,.....
##OOOOOVVVVVaaaaaxxxxxsssssffffflllllcccc/////!!!!!;;;;;,,,,,...
##OOOOOVVVVVaaaaaxxxxxsssssfffffflllllccccc/////!!!!!;;;;;,,,,,.
#OOOOOOVVVVVaaaaaxxxxxxsssssfffffflllllccccc//////!!!!!;;;;;;,,,
OOOOOOVVVVVVaaaaaaxxxxxssssssfffffflllllcccccc//////!!!!!;;;;;;,
OOOOOOVVVVVVaaaaaaxxxxxxssssssffffffllllllcccccc//////!!!!!!;;;;
OOOOOVVVVVVVaaaaaaxxxxxxsssssssfffffflllllllcccccc///////!!!!!!;
OOOOOVVVVVVaaaaaaaxxxxxxxsssssssffffffflllllllccccccc//////!!!!!
OOOOVVVVVVVaaaaaaaaxxxxxxxsssssssfffffffflllllllccccccc////////!
OOOVVVVVVVVaaaaaaaaxxxxxxxxssssssssffffffffllllllllcccccccc/////
OOVVVVVVVVVaaaaaaaaaxxxxxxxxsssssssssfffffffflllllllllcccccccc//
OVVVVVVVVVVaaaaaaaaaxxxxxxxxxssssssssssffffffffflllllllllccccccc
VVVVVVVVVVaaaaaaaaaaaxxxxxxxxxxssssssssssfffffffffffllllllllllcc
VVVVVVVVVVaaaaaaaaaaaxxxxxxxxxxxxsssssssssssffffffffffffllllllll
VVVVVVVVVVaaaaaaaaaaaaxxxxxxxxxxxxxsssssssssssssffffffffffffflll
VVVVVVVVVaaaaaaaaaaaaaaaxxxxxxxxxxxxxxsssssssssssssssfffffffffff
VVVVVVVVaaaaaaaaaaaaaaaaaxxxxxxxxxxxxxxxxxxsssssssssssssssssffff
VVVVVVVaaaaaaaaaaaaaaaaaaaaaxxxxxxxxxxxxxxxxxxxxssssssssssssssss
VVVVVVaaaaaaaaaaaaaaaaaaaaaaaaaxxxxxxxxxxxxxxxxxxxxxxxxxxsssssss
VVVaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxxxxxxxxxxxxxxxxxxxxxxxxxxx
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxxxxxxxxxxxxxxx
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaVVVVVVVVVVVVVVVVVVV
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
aaaaaaaaaaaaaaaaaaaaaaaaVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVOOOOOO
aaaaaaaaaaaaaaaaaaaaaVVVVVVVVVVVVVVVVVVVVVVVVVVOOOOOOOOOOOOOOOOO
aaaaaaaaaaaaaaaaaaaaVVVVVVVVVVVVVVVVVVVVOOOOOOOOOOOOOOOOOOOOO###

The above image is constructed by applying bilinear interpolation to the four corner values.

The principle is simple: first linearly interpolate in one direction (e.g. horizontal), then in the other (vertical). Mathematically the order in which we take the dimensions doesn't matter (but it may matter practically due to rounding errors etc.).

Example: let's say we want to compute the value x between the four following given corner values:

1 . . . . . . 5
. . . . . . . .
. . . . . . . . 
. . . . . . . .
. . . . . . . .
. . . . x . . .
. . . . . . . .
8 . . . . . . 3

Let's say we first interpolate horizontally: we'll compute one value, a, on the top (between 1 and 5) and one value, b, at the bottom (between 8 and 3). When computing a we interpolate between 1 and 5 by the horizontal position of x (4/7), so we get a = 1 + 4/7 * (5 - 1) = 23/7. Similartly b = 8 + 4/7 * (3 - 8) = 36/7. Now we interpolate between a and b vertically (by the vertical position of x, 5/7) to get the final value x = 23/7 + 5/7 * (36/7 - 23/7) = 226/49 ~= 4.6. If we first interpolate vertically and then horizontally, we'd get the same result (the value between 1 and 8 would be 6, the value between 5 and 3 would be 25/7 and the final value 226/49 again).

Here is a C code to compute all the inbetween values in the above, using fixed point (no float):

#include <stdio.h>

#define GRID_RESOLUTION 8

int interpolateLinear(int a, int b, int t)
{
  return a + (t * (b - a)) / (GRID_RESOLUTION - 1);
}

int interpolateBilinear(int topLeft, int topRight, int bottomLeft, int bottomRight,
  int x, int y)
{
#define FPP 16 // we'll use fixed point to prevent rounding errors
    
#if 1 // switch between the two versions, should give same results:
  // horizontal first, then vertical
  int a = interpolateLinear(topLeft * FPP,topRight * FPP,x);
  int b = interpolateLinear(bottomLeft * FPP,bottomRight * FPP,x);
  return interpolateLinear(a,b,y) / FPP;
#else
  // vertical first, then horizontal
  int a = interpolateLinear(topLeft * FPP,bottomLeft * FPP,y);
  int b = interpolateLinear(topRight * FPP,bottomRight * FPP,y);
  return interpolateLinear(a,b,x) / FPP;
#endif
}

int main(void)
{
  for (int y = 0; y < GRID_RESOLUTION; ++y)
  {
    for (int x = 0; x < GRID_RESOLUTION; ++x)
      printf("%d ",interpolateBilinear(1,5,8,3,x,y));

    putchar('\n');
  }
    
  return 0;
}

The program outputs:

1 1 2 2 3 3 4 5 
2 2 2 3 3 4 4 5 
3 3 3 3 4 4 4 5 
4 4 4 4 4 4 4 5 
5 5 5 5 5 5 5 4 
6 6 6 6 5 5 5 4 
7 7 7 6 6 5 5 4 
8 8 7 6 6 5 4 3

Cool hack to improve bilinear interpolation (from https://iquilezles.org/articles/texture): bilinear interpolation doesn't looks as good as bicubic but bicubic is a lot more complex on hardware and bandwidth as it requires fetching more texels -- there is one trick which shader programmers use to improve the look of bilinear filtering while not requiring fetching more texels. They use the smoothstep function on the interpolation parameter which eliminates instant "jumps" at edges between texels, it replaces straight lines with a smoother curve and so makes the derivative of the result continuous -- basically it looks a lot better. Still not as good as bicubic but close enough.

TODO: code for the above

Billboard

In 3D computer graphics billboard is a flat image placed in the scene that rotates so that it's always facing the camera. Billboards used to be greatly utilized instead of actual 3D models in old games thanks to being faster to render (and possibly also easier to create than full 3D models), but we can still encounter them even today and even outside retro games, e.g. particle systems are normally rendered with billboards (each particle is one billboard). Billboards are also commonly called sprites, even though that's not exactly accurate.

By axis of rotation there are two main types of billboards:

• Ones rotating only about vertical axis, i.e. billboards that change only their yaw, they only face the camera in a top-down view of the scene. Such sprite may deform on the screen (when the camera is at different height level) just like 3D models do and when viewed completely from above will disappear completely. This may in some situations look better than other options (e.g. in games enemies won't appear lying on their back when seen from above).
• Freely rotating ones, i.e. ones that change all three Euler angles so that they ALWAYS face the camera from any possible angle.

Furthermore there is another subdivision into two main types by HOW the billboards rotate:

• Projection plane aligned: These billboards always align their orientation with the camera's projection plane (they simply rotate themselves in the same way as the camera) which always end up on the screen as an undeformed and unrotated image. This is simple to implement, we can simply blit a 2D image on the rendered 3D view.
• Camera position facing: These billboards face themselves towards the camera's position and copy the camera's roll.

Though the two types above may seem like two same things at first glance, they are in fact not, for the latter we need to know the camera and billboard's positions, for the former we only need the camera's rotation. For simplicity we usually choose to implement the former (projection plane aligned), though the latter may result in look closer to that which would be produced by an actual 3D model of the object.

    projection plane aligned                           position facing

                 |                                          \
                 |                                           |
                 |                                            \

        _.'|                |                       _.'|                |
      <:_  |                |                     <:_  |                |
         '.|                |                        '.|                |
      camera                                      camera
                      |                                            /
                      |                                           |
              |       |                                     _    /
              |                                         _.-' 
              |

Projection plane aligned vs position facing billboards.

Some billboards also choose their image based on from what angle they're viewed (e.g. an enemy in a game viewed from the front will use a different image than when viewed from the side, as seen e.g. in Doom). Also some billboards intentionally don't scale and keep the same size on the screen, for example health bars in some games.

In older software billboards were implemented simply as image blitting, i.e. the billboard's scaled image would literally be copied to the screen at the appropriate position (this would implement the freely rotating billboard). Nowadays when rendering 3D models is no longer really considered harmful to performance and drawing pixels directly is less convenient, billboards are more and more implemented as so called textured quads, i.e. they are really a flat square 3D model that may pass the same pipeline as other 3D models (even though in some frameworks they may actually have different vertex shaders etc.) and that's simply rotated to face the camera in each frame (in modern frameworks there are specific functions for this).

Fun fact: in the old games such as Doom the billboard images were made from photographs of actual physical models from clay. It was easier and better looking than using the primitive 3D software that existed back then.

Implementation Details

The following are some possibly useful things for implementing billboards.

The billboard's position on the screen can be computed by projecting its center point in world coordinates with modelview and projection matrices, just as we project vertices of 3D models.

The billboard's size on the screen shall due to perspective be multiplied by 1 / (tan(FOV / 2) * z) where FOV is the camera's field of view and z is the billboard's distance from camera's projection plane (which is NOT equal to the mere distance from the camera's position, that would create a fisheye lens effect -- the distance from the projection plane can be obtained from the above mentioned projection matrix). (If the camera's FOV is different in horizontal and vertical directions, then also the billboard's size will change differently in these directions.)

For billboards whose images depends on viewing angle we naturally need to compute the angle. We may do this either in 2D or 3D -- most games resort to the simpler 2D case (only considering viewing angle in a single plane parallel to the floor), in which case we may simply use the combination of dot product and cross product between the normalized billboard's direction vector and a normalized vector pointing from the billboard's position towards the camera's position (dot product gives the cosine of the angle, the sign of cross product's vertical component will give the rest of the information needed for determining the exact angle). Once we have the angle, we quantize (divide) it, i.e. drop its precision depending on how many directional images we have, and then e.g. with a switch statement pick the correct image to display. For the 3D case (possible different images from different 3D positions) we may first transform the sprite's 3D facing vector to camera space with appropriate matrix, just like we transform 3D models, then this transformed vector will (again after quantization) directly determine the image we should use.

When implementing the free rotating billboard as a 3D quad that's aligning with the camera projection plane, we can construct the model matrix for the rotation from the camera's normalized directional vectors: R is camera's right vector, U is its up vector and F is its forward vector. The matrix simply transforms the quad's vertices to the coordinate system with bases R, U and F, i.e. rotates the quad in the same way as the camera. When using row vectors, the matrix is following:

R.x R.y R.z 0
U.x U.y U.z 0
F.x F.y F.z 0
0   0   0   1

Bill Gate$

"Some people are so poor that all they've got is money."

William "Bill" Gaytes (28.10.1955 -- TODO) is a mass murderer and rapist (i.e. capitalist) who established and led the terrorist organization Micro$oft. He is one of the most rich and evil individuals in history who took over the world by force establishing the malware "operating system" Window$ as the common operating system, nowadays being dangerous especially by hiding behind his "charity organization" (see charitywashing) which has been widely criticized (see e.g. http://techrights.org/wiki/Gates_Foundation_Critique, even such mainstream media as Wikipedia present the criticism) but which nevertheless makes him look as someone doing "public good" in the eyes of the naive brainless NPC masses.

     \__.,.
   -."     "./
   /,/---"""\\
   ; __   __ ;
  (=[0 ]"[ 0]=)
  \| ""._,"" |/
   |  .___,  |
    \_,   ._/
      "---"
  dead or alive

ASCII portrait of Bill Gaytes

He is really dumb, only speaks one language and didn't even finish university. He also has no moral values, but that goes without saying for any rich businessman. He was owned pretty hard in chess by Magnus Carlsen on some shitty TV show.

When Bill was born, his father was just busy counting dollar bills, so he named him Bill. Bill was mentally retarded as a child and as such had to attend a private school. He never really understood programming but with a below average intelligence he had a good shot at succeeding in business. Thanks to his family connections he got to Harvard where he met Steve Ballmer. Later he dropped out of the school due to his low intelligence.

In 1975 he founded Micro$oft, a malware company named after his dick. By a sequence of extremely lucky events combined with a few dick moves by Bill the company then became successful: when around the year 1980 IBM was creating the IBM PC, they came to Bill because they needed an operating system. He lied to them that he had one and sold them a license even though at the time he didn't have any OS (lol). After that he went to a programmer named Tim Paterson and basically stole (bought for some penny) his OS named QDOS and gave it to IBM, while still keeping ownership of the OS (he only sold IBM a license to use it, not exclusive rights for it). He basically fucked everyone for money and got away with it, the American way. For this he is admired by Americans.

When Bill Gates and Steve Jobs saw how enormously rich they got by abusing the whole world, they got horny and had gay sex together, after which Bill legally changed his name to Bill Gaytes. This however gave Jobs ass cancer and he died.

Binary

The word binary in general refers to having two choices or "two of a thing"; in computer science binary refers to the base 2 numeral system, i.e. a system of writing numbers with only two symbols, usually 1s and 0s, which are commonly interpreted true vs false. We can write any number in binary just as we can with our everyday decimal system (which uses ten digits, as opposed to two), but binary is more convenient for computers because this system is easy to implement in electronics (a switch can be on or off, i.e. 1 or 0; systems with more digits were tried but unsuccessful, they failed miserably in reliability -- see e.g. ternary computers). The word binary is also by extension used for non-textual computer files such as native executable programs or asset files for games.

One binary digit (a "place" for binary value in computer memory) can be used to store exactly 1 bit of information. We mostly use binary digits in two ways:

1. With single bits we represent basic logic values, i.e. true and false, and perform logic operations (e.g. AND, OR etc.) with so called Boolean algebra.
2. By grouping multiple bits together we create a base-2 numeral system that behaves in the same way as our decimal system and can be used to record numbers. We can build this numeral system with the above mentioned Boolean algebra, i.e. we extend our simple one bit system to multi bit system allowing to work not just with two values (true and false) but with many distinct values (whole numbers, from which we may later construct fractions etc.). Thanks to this we can implement algebraic operations such as addition, multiplication, square roots etc.

Of course the binary system didn't appear from nowhere, people in ancient times used similar systems, e.g. the poet Pingala (200 BC) created a system that used two syllables for counting, old Egyptians used so called Eye of Horus, a unit based on power of two fractions etc. Thomas Harriot used something very similar to today's binary in 1600s. It's just that until computers appeared there wasn't much practical use for it, so no one cared.

{ There is one classic but overplayed joke that became extremely cringe exactly by being too overplayed by wannabe haxors who think learning binary makes you Einstein, however since many noobs will likely be reading this and it helps understand the subject, it may be good to tell it anyway. It goes like this: There are 10 types of people -- those who understand binary and those who don't. Sometimes this is extended with: and those who don't know this joke is in base 3. You can also give people the finger by sending them "binary four". ~drummyfish }

Boolean Algebra ("True/False Logic")

In binary we start by working with single bits -- each bit can hold two values, 1 and 0. We may see bits now like "simple numbers", we'll want to do operations with them, but they can only ever be one of the two values. Though we can interpret these values in any way -- e.g. in electronics we see them as high vs low voltage -- in mathematics we traditionally turn to using logic and interpret them as meaning true (1) and false (0). This will further allow us to apply all the knowledge and theory we have gathered about logic, such as formulas that allow us to simplify binary expressions etc.

Next we want to define "operations" we can perform on single bits -- for this we use so called Boolean algebra, which is originally a type of abstract algebra that works with sets and their operations such as conjunction, disjunction etc. Boolean algebra can be seen as a sort of simplified version of what we do in "normal" elementary school algebra -- just as we can add or multiply numbers, we can do similar things with individual bits, we just have a bit different operations such as logic AND, logic OR and so on. Generally Boolean algebra can operate with more than just two values, however that's more interesting to mathematicians; for us all we need now is a binary Boolean algebra -- that's what programmers have adopted for their field. It is the case that in context of computers and programming we implicitly understand Boolean algebra to be the one working with 1s and 0s, i.e. the binary version, so the word "boolean" is essentially used synonymously with "binary" around computers. Many programming languages have a data type called boolean or bool that allows represents just two values (true and false).

The very basic operations, or logic functions, of Boolean algebra are:

• NOT (negation, !): Done with single bit, turns 1 into 0 and vice versa.
• AND (conjunction, /\): Done with two bits, yields 1 only if both input bits are 1, otherwise yields 0. This is similar to multiplication (1 * 1 = 1, 1 * 0 = 0, 0 * 1 = 0, 0 * 0 = 0) .
• OR (disjunction, \/): Done with two bits, yields 1 if at least one of the input bits is 1, otherwise yields 0. This is similar to addition (1 + 1 = 1, 1 + 0 = 1, 0 + 1 = 1, 0 + 0 = 0).

There are also other function such as XOR (exclusive OR, is 1 exactly when the inputs differ) and negated versions of AND and OR (NAND and NOR, give opposite outputs of the respective non-negated function). The functions are summed up in the following table (we all these kinds of tables truth tables):

In fact there exists more functions with two inputs and one output (16 in total, computing this is left as exercise :]). However not all are named -- we only use special names for the commonly used ones, mostly the ones in the table above.

An interesting thing is that we may only need one or two of these functions to be able to create all other function (this is called functional completeness); for example it is enough to only have AND and NOT functions together to be able to construct all other functions. Functions NAND and NOR are each enough by themselves to make all the other functions! For example NOT x = x NAND x, x AND y = NOT (x NAND y) = (x NAND y) NAND (x NAND y), x OR y = (x NAND x) NAND (y NAND y) etc.

Boolean algebra further tells us some basic laws we can use to simplify our expressions with these functions, for example:

• trivial laws:
  • x AND 0 = 0
  • x OR 1 = 1
  • x AND 1 = x
  • x OR 0 = x
  • x AND x = x
  • x OR x = x
  • commutativity of OR: x OR y = y OR x
  • commutativity of OR: x AND y = y AND x
  • associativity of AND: x OR (x OR x) = (x OR x) OR x
  • associativity of AND: x AND (x AND x) = (x AND x) AND x
  • ...
• distributive laws:
  • x AND (y OR z) = (x AND y) OR (x AND z)
  • x OR (y AND z) = (x OR y) AND (x OR z)
• De Morgan's laws:
  • NOT (x AND y) = NOT(x) OR NOT(y)
  • NOT (x OR y) = NOT(x) AND NOT(y)
• ...

By combining all of these simple functions it is possible to construct not only operations with whole numbers and traditional algebra, but also a whole computer that renders 3D graphics and sends multimedia over the Internet. For more details see logic circuits.

Base-2 Numeral System

While we may use a single bit to represent two values, we can group more bits together and become able to represent more values; the more bits we group together, the more values we'll be able to represent as possible combinations of the values of individual bits. The number of bits, or "places" we have for writing a binary number is called a number of bits or bit width. A bit width N allows for storing 2^N values -- e.g. with 2 bits we can store 2^2 = 4 values: 0, 1, 2 and 3, in binary 00, 01, 10 and 11. With 3 bits we can store 2^3 = 8 values: 0 to 7, in binary 000, 001, 010, 011, 100, 101, 110, 111. And so on.

At the basic level binary works just like the decimal (base 10) system we're used to. While the decimal system uses powers of 10, binary uses powers of 2. Here is a table showing a few numbers in decimal and binary:

Conversion to decimal: let's see an example that utilizes the facts mentioned above. Let's have a number that's written as 10135 in decimal. The first digit from the right (5) says the number of 10^(0)s (1s) in the number, the second digit (3) says the number of 10^(1)s (10s), the third digit (1) says the number of 10^(2)s (100s) etc. Similarly if we now have a number 100101 in binary, the first digit from the right (1) says the number of 2^(0)s (1s), the second digit (0) says the number of 2^(1)s (2s), the third digit (1) says the number of 2^(2)s (4s) etc. Therefore this binary number can be converted to decimal by simply computing 1 * 2^0 + 0 * 2^1 + 1 * 2^2 + 0 * 2^3 + 0 * 2^4 + 1 * 2^5 = 1 + 4 + 32 = 37.

100101 = 1 + 4 + 32 = 37
||||||
\\\\\\__number of 2^0s (= 1s)
 \\\\\__number of 2^1s (= 2s)
  \\\\__number of 2^2s (= 4s)
   \\\__number of 2^3s (= 8s)
    \\__number of 2^4s (= 16s)
     \__number of 2^5s (= 32s)

To convert from decimal to binary we can use a simple algorithm that's again derived from the above. Let's say we have a number X we want to write in binary. We will write digits from right to left. The first (rightmost) digit is the remainder after integer division of X by 2. Then we divide the number by 2. The second digit is again the remainder after division by 2. Then we divide the number by 2 again. This continues until the number is 0. For example let's convert the number 22 to binary: first digit = 22 % 2 = 0; 22 / 2 = 11, second digit = 11 % 2 = 1; 11 / 2 = 5; third digit = 5 % 2 = 1; 5 / 2 = 2; 2 % 2 = 0; 2 / 2 = 1; 1 % 2 = 1; 1 / 2 = 0. The result is 10110.

NOTE: once we start grouping bits to create numbers, we typically still also keep the possibility to apply the basic Boolean operations to these bits. You will sometimes encounter the term bitwise operation which signifies an operation that works on the level of single bits by applying given function to bits that correspond by their position; for example a bitwise AND of values 1010 and 1100 will give 1000.

Operations with binary numbers: again, just as we can do arithmetic with decimal numbers, we can do the same with binary numbers, even the algorithms we use to perform these operations with pen and paper work basically the same. For example the following shows multiplication of 110 (6) by 11 (3) to get 10010 (18):

  110 *
   11
  ___
  110
 110
 ____
10010

All of these operations can be implemented just using the basic boolean functions -- see logic circuits and CPUs.

In binary it is very simple and fast to divide and multiply by powers of 2 (1, 2, 4, 8, 16, ...), just as it is simply to divide and multiple by powers of 10 (1, 10, 100, 1000, ...) in decimal (we just shift the radix point, e.g. the binary number 1011 multiplied by 4 is 101100, we just added two zeros at the end). This is why as a programmer you should prefer working with powers of two (your programs can be faster if the computer can perform basic operations faster).

Binary can be very easily converted to and from hexadecimal and octal because 1 hexadecimal (octal) digit always maps to exactly 4 (3) binary digits. E.g. the hexadeciaml number F0 is 11110000 in binary (1111 is always equaivalent to F, 0000 is always equivalent to 0). This doesn't hold for the decimal base, hence programmers often tend to avoid base 10.

We can work with the binary representation the same way as with decimal, i.e. we can e.g. write negative numbers such as -110101 or rational numbers (or even real numbers) such as 1011.001101. However in a computer memory there are no other symbols than 1 and 0, so we can't use extra symbols such as - or . to represent such values. So if we want to represent more numbers than non-negative integers, we literally have to only use 1s and 0s and choose a specific representation/format/encoding of numbers -- there are several formats for representing e.g. signed (potentially negative) or rational (fractional) numbers, each with pros and cons. The following are the most common number representations:

• two's complement: Allows storing integers, both positive, negative and zero. It is probably the most common representation of integers because of its great advantages: basic operations (+, -, *) are performed exactly the same as with "normal" binary numbers, and there is no negative zero (which would be an inconvenience and waste of memory). Inverting a number (from negative to positive and vice versa) is done simply by inverting all the bits and adding 1. The leftmost bit signifies the number's sign (0 = +, 1 = -).
• sign-magnitude: Allows storing integers, both positive, negative and zero. It's pretty straightforward: the leftmost bit in a number serves as a sign (0 means +, 1 means -) and the rest of the number is the distance from zero in "normal" representation. So e.g. a 4 bit number 0011 is 3 while 1011 is -3 (note that we have to know the bit width of the number here, e.g. on 8 bits -3 would be 10000011). The disadvantage is there are two values for zero (positive, 0000 and negative, 1000) which wastes a value and presents a computational inconvenience, and operations with these numbers are more complicated and slower (checking the sign requires extra code).
• one's complement: Allows storing integers, both positive, negative and zero. The leftmost bit signifies a sign, in the same way as with sign-magnitude, but numbers are inverted differently: a positive number is turned into negative (and vice versa) by inverting all bits. So e.g. 0011 is 3 while 1100 is -3 (again, bit width matters). The disadvantage is there are two values for zero (positive, 0000 and negative, 1111) which wastes a value and presents a computational inconvenience, and some operations with these numbers may be more complex.
• fixed point: Allows storing rational numbers (fractions), i.e. numbers with a radix point (such as 1101.011), which can also be positive, negative or zero. It works by imagining a radix point at some fixed position in the binary representation, e.g. if we have an 8 bit number, we may consider 5 leftmost bits to represent the whole part and 3 rightmost bits to be the fractional part (so e.g the number 11010110 represents 11010.110). The advantage here is extreme simplicity (we can use normal integer numbers as fixed point simply by imagining a radix point). The disadvantage may be low precision and small range of representable values.
• floating point: Allows storing rational numbers in great ranges, both positive, negative and zero, plus some additional values such as infinity and not a number. It allows the radix point to be shifted which gives a potential for storing extremely big and extremely small numbers at the same time. The disadvantage is that float is extremely complex, bloated, wastes some values and for fast execution requires a special hardware unit (which most "normal" computers nowadays have, but are missing e.g. in some embedded systems).
• ...

As anything can be represented with numbers, binary can be used to store any kind of information such as text, images, sounds and videos. See data structures and file formats.

Binary numbers can nicely encode sets: one binary number can be seen as representing a set, with each bit saying whether an object is or is not present. For example an 8 bit number can represent a set of whole numbers 0 to 7. Consider e.g. a value S1 = 10000101 and S2 = 01001110; S1 represents a set { 0, 2, 7 }, S2 represents a set { 1, 2, 3, 6 }. This is natural and convenient, no bits are wasted on encoding order of numbers, only their presence or absence is encoded, and many set operations are trivial and very fast. For example the basic operations on sets, i.e. union, intersection, complement are simply performed with boolean operators OR, AND and NOT. Also checking membership, adding or removing numbers to the set etc. are very simple (left as an exercise for the reader lol; also another exercise -- in a similar fashion, how would you encode a multiset?). This is actually very useful and commonly used, for example chess engines often use 64 bit numbers to represent sets of squares on a chessboard.

See Also

• unary
• ternary
• logic circuit
• bit
• hexadecimal
• De Morgan's laws
• data structure
• data type

Bit Hack

Bit hacks (also bit tricks, bit magic, bit twiddling etc.) are simple clever formulas for performing useful operations with binary numbers. Some operations, such as checking if a number is power of two or reversing bits in a number, can be done very efficiently with these hacks, without using loops, branching and other undesirably slow operations, potentially increasing speed and/or decreasing size and/or memory usage of code -- this can help us optimize. Many of these can be found on the web and there are also books such as Hacker's Delight which document such hacks.

Basics

Basic bit manipulation techniques are common and part of general knowledge so they won't be listed under hacks, but for sake of completeness and beginners reading this we should mention them here. Let's see the basic bit manipulation operators in C:

• | (bitwise OR): Performs the logical OR on all corresponding bits of two operands, e.g. 0b0110 | 0b1100 gives 0b1110 (14 in decimal). This is used to set bits and combine flags (options) into a single numeric value that can easily be passed to function etc. For example to set the lowest bit of a number to 1 just do myNumber | 1. Now consider e.g. #define OPTION_A 0b0001, #define OPTION_B 0b0010 and #define OPTION_C 0b0100, now we can make a single number that represents a set of selected options e.g. as OPTION_C | OPTION_B (the value will be 0101 and says that options B and C have been selected).
• & (bitwise AND): Performs the logical AND on all corresponding bits of two operands, e.g. 0b0110 & 0b1100 gives 0b0100 (4 in decimal). This may be used to mask out specific bits, to check if specific bits are set (useful to check the set flags as mentioned above) or to clear (set to zero) specific bits. Consider the flag example from above, if we want to check if value x has e.g. the option B set, we simply do x & OPTION_B which results in non-zero value if the option is set. Another example may be myNumber & 0b00001111 (in practice you'll see hexadecimal values, i.e. myNumber & 0x0F) which masks out the lowest 4 bits of myNumber (which is equivalent to the operation modulo 16).
• ~ (bitwise NOT): Flips every bit of the number -- pretty straightforward. This is used e.g. for clearing bits as x & ~(1 << 3) (clear 4th bit of x).
• ^ (bitwise XOR): Performs the logical XOR on all corresponding bits of two operands, e.g. 0b0110 ^ 0b1100 gives 0b1010 (10 in decimal). This is used to e.g. flip specific bits.
• << and >> (binary shift left/right): Performs bitwise shift left or right (WATCH OUT: shifting by data type width or more is undefined behavior in C). This is typically used to perform fast multiplication (left) and division (right) by powers of two (2, 4, 8, 16, ...), just as we can quickly multiply/divide by 10 in decimal by shifting the decimal point. E.g. 5 << 3 is the same as 5 * 2^3 = 5 * 8 = 40.
• We also sometimes use the logical (i.e. NOT bitwise) operators && (AND), || (OR) and ! (NOT); the difference against bitwise operators is that firstly they work with the whole value (i.e. not individual bits), considering 0 to be false and anything else to be true, and secondly they may employ a bit more complexity, e.g. short circuit evaluation.

Specific Bit Hacks

{ Work in progress. I'm taking these from various sources such as the Hacker's Delight book or web and rewriting them a bit, always testing. Some of these are my own. ~drummyfish }

TODO: stuff from this gophersite: gopher://bitreich.org/0/thaumaturgy/bithacks

Unless noted otherwise we suppose C syntax and semantics and integer data types, but of course we mainly want to express formulas and patterns you can use anywhere, not just in C. Keep in mind all potential dangers, for example it may sometimes be better to write an idiomatic code and let compiler do the optimization that's best for given platform, also of course readability will worsen etc. Nevertheless as a hacker you should know about these tricks, it's useful for low level code etc.

2^N: 1 << N

absolute value of x (two's complement):

  int t = x >> (sizeof(x) * 8 - 1);
  x = (x + t) ^ t;

average x and y without overflow: (x & y) + ((x ^ y) >> 1) { TODO: works with unsigned, not sure about signed. ~drummyfish }

clear (to 0) Nth bit of x: x & ~(1 << N)

clear (to 0) rightmost 1 bit of x: x & (x - 1)

conditionally add (subtract etc.) x and y based on condition c (c is 0 or 1): x + ((0 - c) & y), this avoids branches AND ALSO multiplication by c, of course you may replace + by another operators.

count 0 bits of x: Count 1 bits and subtract from data type width.

count 1 bits of x (8 bit): We add neighboring bits in parallel, then neighboring groups of 2 bits, then neighboring groups of 4 bits.

  x = (x & 0x55) + ((x >> 1) & 0x55);
  x = (x & 0x33) + ((x >> 2) & 0x33);
  x = (x & 0x0f) + (x >> 4);

count 1 bits of x (32 bit): Analogous to 8 bit version.

  x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
  x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
  x = (x & 0x0f0f0f0f) + ((x >> 4) & 0x0f0f0f0f);
  x = (x & 0x00ff00ff) + ((x >> 8) & 0x00ff00ff);
  x = (x & 0x0000ffff) + (x >> 16);

count leading 0 bits in x (8 bit):

  int r = (x == 0);
  if (x <= 0x0f) { r += 4; x <<= 4; }
  if (x <= 0x3f) { r += 2; x <<= 2; }
  if (x <= 0x7f) { r += 1; }

count leading 0 bits in x (32 bit): Analogous to 8 bit version.

  int r = (x == 0);
  if (x <= 0x0000ffff) { r += 16; x <<= 16; }
  if (x <= 0x00ffffff) { r += 8; x <<= 8; }
  if (x <= 0x0fffffff) { r += 4; x <<= 4; }
  if (x <= 0x3fffffff) { r += 2; x <<= 2; }
  if (x <= 0x7fffffff) { r += 1; }

divide x by 2^N: x >> N

divide x by 3 (unsigned at least 16 bit, x < 256): ((x + 1) * 85) >> 8, we use kind of a fixed point multiplication by reciprocal (1/3), on some platforms this may be faster than using the divide instruction, but not always (also compilers often do this for you). { I checked this particular trick and it gives exact results for any x < 256, however this may generally not be the case for other constants than 3. Still even if not 100% accurate this can be used to approximate division. ~drummyfish }

divide x by 5 (unsigned at least 16 bit, x < 256): ((x + 1) * 51) >> 8, analogous to divide by 3.

get Nth bit of x: (x >> N) & 0x01

is x a power of 2?: x && ((x & (x - 1)) == 0)

is x even?: (x & 0x01) == 0

is x odd?: (x & 0x01)

isolate rightmost 0 bit of x: ~x & (x + 1)

isolate rightmost 1 bit of x: x & (~x + 1) (in two's complement equivalent to x & -x)

log base 2 of x: Count leading 0 bits, subtract from data type width - 1.

maximum of x and y: x ^ ((0 - (x < y)) & (x ^ y))

minimum of x and y: x ^ ((0 - (x > y)) & (x ^ y))

multiply x by 2^N: x << N

multiply by 7 (and other numbers close to 2^N): (x << 3) - x

next higher or equal power of 2 from x (32 bit):

  x--;
  x |= x >> 1;
  x |= x >> 2;
  x |= x >> 4;
  x |= x >> 8;
  x |= x >> 16;
  x = x + 1 + (x == 0);

parity of x (8 bit):

  x ^= x >> 1;
  x ^= x >> 2;
  x = (x ^ (x >> 4)) & 0x01;

reverse bits of x (8 bit): We switch neighboring bits, then switch neighboring groups of 2 bits, then neighboring groups of 4 bits.

  x = ((x >> 1) & 0x55) | ((x & 0x55) << 1);
  x = ((x >> 2) & 0x33) | ((x & 0x33) << 2);
  x = ((x >> 4) & 0x0f) | (x << 4);

reverse bits of x (32 bit): Analogous to the 8 bit version.

  x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
  x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
  x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
  x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
  x = ((x >> 16) & 0x0000ffff) | (x << 16);

rotate x left by N (8 bit): (x << N) | (x >> (8 - N)) (watch out, in C: N < 8, if storing in wider type also do & 0xff)

rotate x right by N (8 bit): analogous to left rotation, (x >> N) | (x << (8 - N))

set (to 1) Nth bit of x: x | (1 << N)

set (to 1) the rightmost 0 bit of x: x | (x + 1)

set or clear Nth bit of x to b: (x & ~(1 << N)) | (b << N)

sign of x (returns 1, 0 or -1): (x > 0) - (x < 0)

swap x and y (without tmp var.): x ^= y; y ^= x; x ^= y; or x -= y; y += x; x = y - x;

toggle Nth bit of x: x ^ (1 << N)

toggle x between A and B: (x ^ A) ^ B

x and y have different signs?: (x > 0) == (y > 0), (x <= 0) == (y <= 0) etc. (differs on 0:0 behavior)

TODO: the ugly hacks that use conversion to/from float?

See Also

• De Morgan's laws
• fast inverse square root
• optimization

Bit

Bit (for binary digit, symbol b, also shannon) is the lowest commonly used unit of information, equivalent to a choice between two equally likely options (e.g. an answer to the question "Was the coin flip heads?"), in computers used as the smallest unit of memory, with 1 bit being able to hold exactly one value that can be either 1 or 0. From bit a higher memory unit, byte (8 bits), is derived. In quantum computing the equivalent of a bit is qubit, in ternary computers the analogy is trit.

Can there exist a smaller quantity of information than 1 bit? Well, yes, for sure we can get zero information and it certainly also makes sense to speak of fractions of bits; for example one decimal digit carries log2(10) ~= 3.32 bits of information. Entropy is also measured in bits and can get smaller than 1 bit, e.g. for an unfair coin toss; an answer to the question "Will the Sun rise tomorrow?" gives less than 1 bit of information -- in fact it gives almost no information as we know the answer will most definitely be yes, though the certainty can never be absolute. Another idea: imagine there exist two people for whom we want to know, based on their sexes, whether they may reproduce together -- answer to this question takes 1 bit (yes or no) and to obtain it we have to know both of these people's sexes so we can say whether they differ. Now if we only know the sex of one of them, then in the context of the desired answer we might perhaps say we have a half of one bit of information, as if we also know the other one's sex (the other half of the bit), we get the whole 1 bit answer.

Bitreich

{ Researching this on-the-go, send me corrections, thanks. ~drummyfish }

Bitreich is a small, obscure underground group/movement of programmers who greatly value minimalism/simplicity, oppose the evil and degeneration of modern mainstream technology and aim for making the world a better place mainly through simpler technology. They seem to belong to the cluster of "minimalist programmer groups", i.e. they are similar to suckless (which in their manifesto they see as a failed project), reactionary software and our very own LRS, sharing many values such as minimalism, Unix philosophy, preference and love of the C language, carrying on some of the hacker culture heritage, though of course they also have their own specifics that will make them different and even disagreeing with us and others on occasion, e.g. on copyleft (unlike us, they seem to greatly prefer the GPL), terminology (yeah, they seems to prefer "open source") and probably also things like privacy (though the craze doesn't seem to go too far, many have listed their real names and addresses) etc.

According to the gopherhole Bitreich started on 17.8.2016 -- the founder (or at least one of them?) seems to be 20h (Christoph Lohmann according to the user profile), a guy formerly active in suckless (can be found on their website), who even gave an interview about Bitreich to some radio/magazine/whatever. It seems Bitreich originated in Germany. As of 2023 they list 12 official member profiles (the number of lurker followers will of course be a much high number, there seem to be even bitreich subcommunities in other countries such as Italy). They are mostly present on gopher (gopher://bitreich.org), which they greatly promote, and IRC (ircs://irc.bitreich.org:6697/#bitreich-en). There are also Tor hidden services etc.; their website at bitreich.org seems to be purposefully broken in protest of the web horror.

Some of their ideas and philosophy seems to be very based, e.g. preference of KISS/older protocols (gopher, ftp, IRC, ...), "users are programmers" (opposing division into users as consumers and developers as overlords), "bug reports are patches", "programs can be finished" etc.

Bitreich is also about humor and fun (sometimes so much so that it's not clear if something is a joke or serious stuff -- maybe because it's partly both). They invented analgram, an authentication method based on analprints (alternative to fingerprint authentication). They put a snapshot of their source code into an actual Arctic vault in Greenland, to be preserved for millennia. Often there appear parodies of whatever is currently hyping in the mainstream, e.g. NFTs, "big data", AI, blockchain etc. { There's also some stuff going on with memes and cooking recipes but TBH I didn't get it. ~drummyfish }

Some interesting projects they do:

• Bitreichcon: annual conference, running since 2017. Their slides can be downloaded in plain text.
• Bitreich radio
• Day Of The GrParazyd: point and click adventure game. { Didn't even take a look at this yet, sorry, no idea what it really is :D ~drummyfish }
• The Gopher Lawn: directory/index of gopherspace, categorizing gopherhole links.
• The Gopher Times: a very cool printable magazine (in both pdf and plain text), git clone git://bitreich.org/tgtimes.
• A number of smaller utilities/programs and parody stuff (see their gopherhole).
• Keeping infrastructure to host stuff they see as valuable.
• ...

See Also

• suckless
• reactionary software
• less retarded software
• KISS

Black

Black, a color whose politically correct name is afroamerican, is a color that we see in absence of any light.

Blender

Blender (also Blunder) is a greatly complex "open-source" 3D modeling and rendering software -- one of the most powerful and "feature-rich" ones, even compared to proprietary competition -- used not only by the FOSS community, but also the industry (commercial games, movies etc.), which is an impressive achievement in itself, however Blender is also a capitalist software suffering from many not-so-nice features such as bloat, update culture, hardware discrimination and centralized control.

After version 2.76 Blender started REQUIRING OpenGL 2.1 due to its "modern" EEVEE renderer, deprecating old machines and giving a huge fuck you to all users with incompatible hardware (for example the users of RYF laptops). This new version also stopped working with the free Nouveau driver, forcing the users to use NVidia's proprietary drivers. Blender of course doesn't at all care about this. { I've been forced to use the extremely low FPS software GL version of Blender after 2.8. ~drummyfish }

Are there good alternatives to Blender? Some programs to check out are wings3d (seems like the best candidate), k3d, meshlab and mm3d (looks like bloat), also for some things possibly FreeCAD. Remember you can also make models manually :-) Formats like obj can be hand-written.

See Also

• 3D modeling

Bloat

Bloat is a very wide term that in the context of software and technology means overcomplication, unnecessary complexity and/or extreme growth in terms of source code size, overall complexity, number of dependencies, redundancy, unnecessary and/or useless features (e.g. feature creep) and resource usage, all of which lead to inefficient, badly designed technology with bugs (crashes, unusable features, memory leaks, security vulnerabilities, ...), as well as great obscurity, ugliness, loss of freedom and waste of human effort. Simply put bloat is burdening bullshit. Bloat is extremely bad and one of the greatest technological issues of today. Creating bloat is bad engineering at its worst and unfortunately it is what's absolutely taking over all technology nowadays, mostly due to capitalism causing commercialization, consumerism, rushed "just works" products, creating demand for newer hardware and so on, also allowing incompetent people ("let's push more women/minorities into programming") trying to take on jobs they are in no way qualified to do.

A related but different term is bloatware; it's more commonly used among normie users and stands for undesirable programs that eat up computer resources, usually being preinstalled by the computer manufacturer etc. Further on we'll rather focus on bloat as defined before.

TODO: history of bloat?

LRS, suckless and some others rather small groups are trying to address the issue and write software that is good, minimal, reliable, efficient and well functioning. Nevertheless our numbers are very small and in this endeavor we are basically standing against the whole world and the most powerful tech corporations. The issue lies not only in capitalism pushing bloat but also in common people not seeing the issue (partly due to the capitalist propaganda promoting maximalism), no one is supporting the few people who are genuinely trying to create good tools, on the contrary such people often face hostility from the mainstream.

The issue of bloat may of course appear outside of the strict boundaries of computer technology, nowadays we may already observe e.g. science bloat -- science is becoming so overcomplicated (many times on purpose, e.g. by means of bullshit science) that 99% people can NOT understand it, they have to BELIEVE "scientific authorities", which does not at all differ from the dangerous blind religious behavior. Any time a new paper comes out, chances are that not even SCIENTISTS from the same field but with a different specialization will understand it in depth and have to simply trust its results. This combined with self-interest obsessed society gives rise to soyence and large scale brainwashing and spread of "science approved" propaganda.

Some metrics traditionally used to measure bloat include lines of source code, cyclomatic complexity (kind of "number of ways the code may take"), programming language used (some languages are bloated themselves and inherently incapable of producing non-bloat, also choice of language indicates the developer's priorities, skills etc.), number of dependencies (packages, libraries, hardware, ...), binary size (size of the compiled program), compile time, resource usage (RAM, CPU, network usage, ...), performance (FPS, responsiveness, ...), anti features (GUI, DRM, auto updates, file formats such as XML, ...), portability, number of implementations, size of specification, number of developers and others. Some have attempted to measure bloat in more sophisticated ways, e.g. the famous web bloat score (https://www.webbloatscore.com/) measures bloat of websites as its total size divided by the page screenshot size (e.g. YouTube at 18.5 vs suckless.org at 0.386). It has been observed that software gets slower faster than hardware gets faster, which is now known as Wirth's law; this follows from Moore's law (speed of hardware doubles every 24 months) being weaker than Gate's law (speed of software halves every 18 months); or in other words: the stupidity of soydevs outpaces the brilliancy of geniuses.

Despite this there isn't any completely objective measure that would say "this software has exactly X % of bloat", bloat is something judged based on what we need/want, what tradeoffs we prefer etc. The answer to "how much bloat" there is depends on the answer to "what really is bloat?". To answer this question most accurately we can't limit ourselves to simplifications such as lines of code or number of package dependencies -- though these are very good estimates for most practical purposes, a more accurate insight is obtained by carefully asking what burdens and difficulties of ANY kind come with given technology, and also whether and how much of a necessary evil they are. Realize for example that if your software doesn't technically require package X to run or be compiled, package X may be de facto required for your software to exist and work (e.g. a pure multiplayer game client won't have the server as a dependency, but it will be useless without a server, so de facto all bloat present in the server is now in a wider sense also the client's burden). So if you've found a program that's short and uses no libraries, you still have to check whether the language it is written in isn't bloated itself, whether the program relies on running on a complex platform that cannot be implemented without bloat, whether some highly complex piece of hardware (e.g. GPU or 8GB of RAM) is required, whether it relies on some complex Internet service etc. You can probably best judge the amount of bloat most objectively by asking the following: if our current technology instantly disappeared, how hard would it be to make this piece of technology work again? This will inevitably lead you to investigating how hard it would be to implement all the dependencies etc.

For a quick overview let us average some data over time -- the table that follows shows growth of system requirements and sizes and averages them to give an estimate of bloat ratio with respect to the first row. Please note some data in the table may not be completely accurate, interpolation/extrapolation was used for missing values, we're only making an estimate after all, but still notice our computing resource usage already grew almost 2000 times despite computers being generally slower and less responsive.

One of a very frequent questions you may hear a noob ask is "How can bloat limit software freedom if such software has a free (or "FOSS") license?" Bloat de-facto limits some of the four essential freedoms (to use, study, modify and share) required for a software to be free. A free license grants these freedoms legally, but if some of those freedoms are subsequently limited by other circumstances, the software becomes effectively less free. It is important to realize that complexity itself goes against freedom because a more complex system will inevitably reduce the number of people being able to execute freedoms such as modifying the software (the number of programmers being able to understand and modify a trivial program is much greater than the number of programmers being able to understand and modify a highly complex million LOC program). This is not any made up reason, it is actually happening and many from the free software community try to address the issue, see e.g. HyperbolaBSD policies on accepting packages which rejects a lot of popular "legally free" software on grounds of being bloat (systemd, dbus, zstd, protobuf, mono, https://wiki.hyperbola.info/doku.php?id=en:philosophy:incompatible_packages). As the number of people being able to execute the basic freedom drops, we're approaching the scenario in which the software is de-facto controlled by a small number of people who can (e.g. due to the cost) effectively study, modify and maintain the program -- and a program that is controlled by a small group of people (e.g. a corporation) is by definition proprietary. If there is a web browser that has a free license but you, a lone programmer, can't afford to study it, modify it significantly and maintain it, and your friends aren't able to do that either, when the only one who can practically do this is the developer of the browser himself and perhaps a few other rich corporations that can pay dozens of full time programmers, then such browser cannot be considered free as it won't be shaped to benefit you, the user, but rather the developer, a corporation.

How much bloat can we tolerate? We are basically trying to get the most for the least price. The following diagram attempts to give an answer:

        external
       "richness"
           A   
   shiny   |    :                :
  bullshit | NO :      YES       : NO
           |    :                :                         ____... .
   luxury  |    :                :             ___________/
           |    :                :    ________/
           |    :              __:___/        \__________
    very   |    :         ____/  :                       \______
   useful  |    :     ___/       :                              \_..
           |    :  __/           :                      path of degeneracy
           |    :_/              :
   useful  |   _:                :
           |  | :                :
           | /  :                :
    does   ||   :                :
   nothing +-----------------------------------------------------> internal complexity
           trivial  simple   solo        big        huge       gigantic
                          manageable

The path of degeneracy drawn in the graph shows how from a certain breaking point (which may actually appear at different places, the diagram is simplified) many software projects actually start getting less powerful and useful as they get more complex -- not all, some project really do stay on the path of increasing their "richness", but this requires great skills, experience, expertise and also a bit of lucky circumstances; in the zone of huge complexity projects start to get extremely difficult to manage -- non-primary tasks such as organization, maintenance and documentation start taking up so many resources that the primary task of actually programming the software suffers, the project crumbles under its own weight and the developers just try to make it fall slower. This happens mostly in projects made by incompetent soydevs, i.e. most today's projects. { Thanks to a friend for pointing out this idea. ~drummyfish }

Please note there may arise some disagreement among minimalist group about where the band is drawn exactly, especially old Unix hackers could be heard arguing for allowing (or even requiring) even trivial programs, maybe as long as the source code isn't shorter than the utility name, but then the discussion might even shift to questions like "what even is a program vs what's just a 10 characters long line" and so on.

As a quick heuristic for judging programs you can really take a look at the lines of code (as long as you know it's a simplification that ignores dependencies, formatting style, language used etc.) and use the following classes (basically derived from how suckless programs are often judged):

• < 10: Extremely small but may be useful, may be also too trivial for such small size to be justifiable, can aim to be completely bug-free. Example could be the cat program.
• 11 to 100: Very small, can be debugged to a great level, many greatly useful utilities, e.g. compression programs, may fit this class.
• 101 to 1000: Small "bigger" kinds of programs, often very minimalist implementations of programs that are usually not minimalist in nature like window managers, interactive text editors, web browsers and so on. Simplified version of comun language, called minicomun, fits here.
• 1001 to 5000: Still considered small, a bit more "feature rich" kind of previous class, you may find minimalist 3D games here, quite powerful programming languages, libraries handling complex file formats (that weren't designed to be minimalist) etc. Currently a lot of LRS programs like SAF, small3dlib and comun would fall here.
• 5001 to 10000: Often imposed upper limit on suckless programs, these programs aren't the smallest possible but may still be called minimalist, they are easily manageable by a single man without much hassle, anyone can modify them and there is a comfortable margin for implementing many "comfort" and fancy features that aren't complete BS. Anarch might be given as an example (if we subtract lines of code taken by game data and count only pure engine code).
• 10001 to 100000: Here things start to be called real bloat but may still be accepted as a compromise, not an "insanely bloated" program, we have to judge on a case by case basis as the transition towards bloat is gradual, but generally projects here must focus on not growing bigger, priority should be on minimizing. We have to consider anything here bloat unless proven otherwise. Minimalist projects end up here when trying to combine minimalism with some mainstream concept, e.g. implementing a complete operating system with all the standard features, trying to reimplement some mainstream, non-minimalist program etc. Example is tcc, the C compiler that has a little over 20000 LOC. Also many "good old" mainstream programs like Doom fall here.
• more: Basically just bloat, some operating systems can perhaps argue they are comparatively small even within this category, but as a matter of fact very few people can manage a codebase this big, issues of bloat start to play a very significant role here, the project should most likely be split or rewritten from scratch in much more simplified way.

Yes, bloat is also unecological and no, it cannot be fixed by replacing fossil fuel cars with cars that run on grass and plastic computers by computers made from recycled cardboards mixed with composted horse shit. It is the immense volume of human ACTIVITY that's required by the bloated technology all around the globe that's inherently unecological by wasting so much effort, keeping focus on maximalism, growth and preventing us from frugality and minimizing resource waste. Just as any other bullshit that requires immense resources to just keep maintaining -- great complexity is just absolutely incompatible with ecology and as much as you dislike it, to achieve truly eco-friendly society we'll have to give up what we have now in favor of something orders of magnitude more simple and if you think otherwise, you are just yet too unexperienced (or remained purposefully ignorant) to have seen the big picture already. Consider that your program having bullshit dependencies such as Python, JavaScript, C++, Java, OpenGL, Vulkan, GPU, VR sets, gigabytes of RAM etcetc. requires having the inherently unecological system up, it needs millions of people doing bullshit jobs that are inherently wasting resources, increasing CO2 and making them not focus on things that have to be done -- yes, even if we replace plastic straws with paper straws. All those people that make the thousand pages standards that are updated every year, reviews of those standards, writing tons and tons of tests for implementations of those standards, electing other people to make those standards, testing their tests, implementing the standards themselves, optimizing them, all of that collectively needing many billions of lines of code and millions of hours of non-programming activities, it all requires complex bureaucracy, organization and management (complex version control systems, wikis, buildings, meeting spaces, ...) and communication tools and tons of other bullshit recursively spawning more and more waste -- all of these people require cars to go to work every day (even if some work from home, ultimately only a few can work from home 100% of the time and even so millions others need to physically go to factories to make all those computers, electricity, chair, food and other things those people need), they require keeping a high bandwidth 100% uptime global Internet network maintained, all of this requiring extra buildings, offices, factories, roads, buildings for governments overseeing the building of those buildings, maintenance of those roads etcetc. A newbie programmer (99.99999% programmers in the field nowadays) just don't see all this because they lack the big picture, a woman forced into programming has hard time comprehending an if statement, how do you expect her to see the deep interconnections between technology and society -- she may know that OpenGL is "something with graphics" and it's just there on every computer by default, she can't even picture the complexity that's behind what she sees on the screen. Hence the overall retardation. You just cannot have people living ecologically and at the same time have what we have now. So yes, by supporting and/or creating bloat you are killing the planet, whether you agree with it or not. No, you can't find excuses out of this, no, paper straws won't help, just admit you love point and click "programming without math" of your own shitty Minecraft clones in Godot even for the price of eliminating all life on Earth, that's fine (no it's not but it's better to just not bullshit oneself).

{ Fucking hell this shit has gone too far with the newest supershit gayme called Cities Skyline II, I literally can't anymore, apparently the game won't run smoothly even on Earth's most advanced supercomputer because, as someone analyzed, the retarddevs use billion poly models for pedestrians without any LOD, I bet they don't even know what it is, they probably don't even know what a computer is, these must be some extra retarded soy idiots making these games now. Though I knew it would come to this and that it will be getting yet much worse, I am always still surprised, my brain refuses to believe anyone would let such a piece or monstrous shit to happen. This just can't be real anymore. ~drummyfish }

Typical Bloat

The following is a list of software usually considered a good, typical example of bloat. However keep in mind that bloat is a relative term, for example vim can be seen as a minimalist suckless editor when compared to mainstream software (IDEs), but at the same time it's pretty bloated when compared to strictly suckless programs.

• Web since the onset of "web 2.0" has been steadily becoming more and more bloated with things such as Adobe Flash and JavaScript (and billions of its web frameworks). By today the situation about web bloat is reaching almost unbearable levels, especially in modern sites such as YouTube. For a great read see The Website Obesity Crisis.
• Ads, spyware, DRM, anti-cheats, anti-viruses, anti-sharing, anti-repair and other anti-user "features" are bloat.
• Desktop environments such as KDE and GNOME. The concept of a desktop environment itself is often considered bloat.
• Windows: one of the best examples of how software should NOT be done.
• Blender: quite useful FOSS 3D editor which however integrates things like a whole video editor, game engine, several renderers, scripting language with text editor and so on.
• CMake: gigantic build system that currently sits on top of a sky-high sandwich of other build systems, its number of dependencies is bigger than the number of retards in observable universe (known as drummyfish's number).
• D-Bus
• Docker
• Electron: GUI framework infamous for its huge resource consumption.
• flatpak: Absolutely horrible "application distribution/execution platform???" with pakcage management, sandboxes and all that kind of shit.
• Systemd: Huge anti-unix do-it-all system taking over GNU/Linux.
• Virtual machines/environments/sandboxes, big abstraction sandwiches (e.g. program running in an interpreter running in a sandbox inside web browser that's running in a virtual machine that's running on an operating system).
• Firefox, Chromium and other mainstream web browsers.
• Java, Python and similar languages.
• IDEs such as VSCode or NetBeans.
• Big game engines such as Unreal, Unity or Godot.
• Practically all commercial games made in the 21st century such as World of Warcraft, Call of Duty etc.
• pulse audio
• office programs (e.g. M$ Office and LibreOffice) and a lot of rich text
• Neural networks aka "AI" that is forced into everything nowadays.
• ...

Some of these programs may be replaced with smaller bloat that basically does the same thing (e.g. produces the same output) just with less bullshit around, for example Libreoffice with Ted, Godot with Irrlicht, Firefox with badwolf etc., however many times the spectacular pompous results these programs produce just cannot essentially be reproduced by anything minimal, wanting to achieve this is really a beginner mistake, the same as wanting to achieve the "Windows experience" on a GNU system. You will never be able to make an Unreal Engine style graphics with a minimalist game engine, just like you won't be able to shoot up your school with well written poetry (in both cases the former is something bad that however most Americans want to do, the latter is something truly good they should want instead). To truly get rid of bloat one has to become able to use truly minimal programs; this means unlearning the indoctrination that "bigger results are better", one has to understand that minimal results themselves are superior AND in addition allow using superior programs (i.e. minimal ones).

Medium And Small Bloat

Besides the typical big programs that even normies admit are bloated there exists also a smaller bloat which many people don't see as such but which is nevertheless considered unnecessarily complex by some experts and/or idealists and/or hardcore minimalists, including us.

Small bloat is a subject of popular jokes such as "OMG he uses a unicode font -- BLOAT!!!". These are good jokes, it's nice to make fun out of one's own idealism. But watch out, this doesn't mean small bloat is only a joke concept at all, it plays an important role in designing good technology. When we identify something as small bloat, we don't necessarily have to completely avoid and reject that concept, we may just try to for example make it optional. In context of today's PCs using a Unicode font is not really an issue for performance, memory consumption or anything else, but we should keep in mind it may not be so on much weaker computers or for example post-collapse computers, so we should try to design systems that don't depend on Unicode.

Also remember that relatively small libraries for things that are easily done without a library, such as fixed point arithmetic, are also bloat.

Small/medium bloat includes for example:

• floating point (complex standard with design issues, requires special hardware for acceleration, fixed point is better)
• config files (and other unnecessary file I/O that requires a file I/O library, not all computers have file systems, configs should be part of source code)
• directories (just have all files on the same level and prefix their file names to organize them)
• library linking (header only libraries are better)
• any GPU, OpenGL (complex hardware and specifications, not all computers have complex GPUs, software rendering is better)
• Unicode (big specification requiring special libraries and big fonts, ASCII is better)
• antialiasing (just ignore aliasing, use low resolution textures etc.)
• 64 bit architectures (they only exist to allow ungodly amounts of RAM, 32 bits completely suffice for any computation, many times even 16 or 8 bits are enough)
• proportional font (fixed width font is better)
• linking, build systems/scripts, makefiles, directories and multiple source code files (just using a compiler or a few-line building shell script, single file source code, header only libraries and single compilation unit programs are better)
• infix notation (postfix notation is better)
• any GUI, window managers (pure text mode is better)
• operating system (bare metal is better)
• multithreading, parallelism, virtual memory, ...
• encryption, security, memory safety (just don't care and/or don't handle sensitive data with computers connected to the internet, don't live in a shitty society)
• X11 (just pure screen drawing is better)
• database software (plain files are better, see flatfile)
• C (something in between C and brainfuck would is likely ideal, e.g. comun or Forth)
• glibc, gcc, clang etc. (better alternatives are tcc, musl, uclibc etc.)
• letter accents/diacritics (can normally be ignored in most languages that use them)
• jpg, png, svg and similar formats (e.g. ppm or farbfeld is better)
• syntax highlight, text formatting, rich text and just colors anywhere they aren't absolutely necessary
• html, markdown (plain text is better)
• x86 instruction set (TODO: what's better? probably some RISC)
• any non-public-domain license (any legal burden introduced by a license is unnecessary bloat)
• dynamic linking/libraries (static linking is better, see Stali)
• web 1.0, gemini (gopher or FTP is better)
• mouse (keyboard is better)
• TCP (UDP is probably better)
• vim (things like ed are probably better?)
• sound (picture is usually enough)
• high resolution (640x480 is probably the maximum you'll ever need, lower resolution takes less RAM and makes rendering faster)
• true color (256 colors, e.g. 332 palette, is better, even 1 bit displays suffice for most things), high FPS (25 is more than enough), high resolution (320 x 240 is more than enough) etc.
• GNU Unix utils (things like busybox or sbase are probably better)
• data types (untyped or single type is better, everything can be just a number)
• package managers (just don't use them, install just a few programs manually, or at least make package managers as simple as possible)
• electricity (mechanical computers may be just fine)
• computers (pen and paper or counting with rocks is better)
• anything wireless (wifi, mice, ...)
• ...

Non-Computer Bloat

The concept of bloat can be applied even outside the computing world, e.g. to non-computer technology, art, culture, law etc. Here it becomes kind of synonymous with bullshit, but using the word bloat says we're seeing the issue from the point of view of someone acquainted with computer bloat. Examples include:

• clothes
• decorations (body, house, ...)
• cars
• using languages other than English or Esperanto
• luxury (big house, yacht with a swimming pool, ...)
• having electricity at home
• ...

See Also

• harmful
• maximalism
• shitware
• obscurity
• shit
• cyclomatic complexity

Bloat Monopoly

Bloat monopoly is an exclusive control over or de-facto ownership of software or even a whole area of technology not by legal means but by means of bloat, or generally just abusing bloat in ways that lead to gaining monopolies, e.g. by establishing standards or even legal requirements (such as the EU mandatory content filters) which only the richest may conform to. Even if given software is FOSS (that is its source code is public and everyone has basic legal rights to it), it can be malicious due to bloat, for example it can still be made practically controlled exclusively by the developer because the developer is the only one with sufficient resources and/or know-how to be able to execute the basic rights such as meaningful modifications of the software, which goes against the very basic principle of free software.

Example: take a look at the web and how Google is gaining control over it by getting the search engine monopoly. It is very clear web along with web browsers has been becoming bloated to ridiculous levels -- this is not a coincidence, bloat is pushed by corporations such as Google to eliminate possible emerging competition. If practically all websites require JavaScript, CSS, HTTPS and similar nonsense, it is becoming much more difficult to crawl them and create a web index, leaving the possibility to crawl the web mostly to the rich, i.e. those who have enough money, time and know-how to do this. Alongside this there is the web browser bloat -- as websites have become extremely complex, it is also extremely complex to make and maintain a web browser, which is why there is only a few of them, all controlled (despite FOSS licenses) by corporations and malicious groups, one of which is Google itself. For these reasons Google loves bloat and encourages it, e.g. simply by ranking bloated webpages better in their search results, and of course by other means (sponsoring, lobbying, advertising, ...).

Bloat monopoly is capitalism's circumvention of free licenses and taking advantage of their popularity. With bloat monopoly capitalists can stick a FOSS license to their software, get an automatic approval (openwashing) of most "open-source" fanbois as well as their free work time, while really staying in control almost to the same degree as with proprietary software.

At the time of writing this if you want to compile so called "open source" Android, you will need a computer with at least 400 GB of space, 16 GB of RAM (but recommended is 32 or 64), a modern 64 bit CPU with multiple cores, and many hours of computational time. How long before we need a million dollar supercomputer to compile an "open source" program? Now ask yourself, is this still real freedom?

Examples of bloat monopoly include mainstream web browsers (furryfox, chromium, ...), Android, Linux, Blender etc. This software is characteristic by its difficulty to be even compiled, yet alone understood, maintained and meaningfully modified by a lone average programmer, by its astronomical maintenance cost that is hard to pay for volunteers, and by aggressive update culture.

Boat Dock

WELCOME :) You find yourself on a strange island.

           ,
           |\
           | \
           |  )
     ______|_/____
~-~-~\           /~-~-~
      "-._____.-"

What is this? Boat is a LRS spinoff of Tour Bus, a famous wiki webring -- see http://meatballwiki.org/wiki/TourBus. Why not join Tour Bus? Because we are antisocial and don't wanna talk to anyone, so we just start our new thing (also they would prolly censor us). Also our island is isolated from the normieland and no buses go here :)

On To The Island

You get greeted by a friendly dog -- WOOF --playfully waggling his tail he leads you around, along the beach. The island seems a bit empty but a few people can be seen here and there loosely associating, looking very passionate about creating various things, some are writing, some constructing weird machines, some copulating. Everyone is naked -- "clothes are bloat" says a weirdo of caveman appearance sitting in front of what appears to be his hut. "We are trying to create stuff, mostly with computers", he says, "also hiding here from the hell out there, trying to live a better life". He scratches his butt and adds: "Seeing you are a living being like myself -- that means you are welcome, come join us if you want."

sightseeing:

• less retarded software: what we create
• less retarded society: what we strive for
• capitalism: what we oppose
• jokes: we also try to have some fun fun

Continue Elsewhere

• boat #1: Tour Bus Stop: meatballwiki, normieland (the main hub of Tour Bus)
• boat #2: [YOUR LINK HERE] :-) TODO, here will be some kinda site related to LRS

How To Join Our Boat Tour

Just link to this site from your site. If you want your site added here as a new departure boat, send me an email -- it's ideal if it's a wiki or something that has something to do with LRS (even remotely, no need to mention LRS, can be just software minimalism or whatever, ...). I don't promise to add everything, but it's pretty likely I'll add you if it's not a complete shit :D When (more like if) a few boats are here, other ones should be added further on to the chain, not here. Remember this isn't supposed to be a link dump but a selection of some kinda thematic quality links that form some nice webring.

Body Shaming

Your body sucks.

Books

Here there will be a constantly WIP list of books that might be of interest to supporters of LRS:

{ Let's aim for quality rather than quantity here, don't put any book that has some connection to our cause here, but rather the ones you've read and which you judge as a quality book that enriched you in some way. ~drummyfish }

• Blackout (2017, Elsberg): Fiction, telling a story of a large blackout in Europe that shows to really be caused by bloated tech. For collapse enjoyers this is an interesting read if only for the detailed description of the consequences a sudden loss of electric power.

• Day of the Triffids (1951, Wyndham): Excellent sci-fi in which civilization comes to an end due to a disaster (won't spoil), very nice for collapse preps or just people enjoying a great story narrated in captivating way :-) The movie is a joke, don't even search for it. Also other books by Wyndham are awesome.

• Einstein: His Life and Universe (Isaacson, 2008): Einstein's biography, quite a nice read about a pretty awesome man who's image has been so distorted by the mainstream shit.

• Encyclopedia Britannica 11th edition (1911): Extremely large, old, uncensored encyclopedia, mostly digitized and fulltext searchable, also completely public domain, with very long articles on all topics up to the date of its publication. Great source of lesser known information and an alternative to modern censored sources. Also check out other similar encyclopedias.

• Flatland (Abbott, 1884): Absolutely amazing fantasy story set in two dimensional land with characters being geometric shapes, while being a critic of society to a big degree, it discusses practical and mathematical aspects of actually living in two dimensions, how the characters see, how they build their houses etc. It is now absolutely public domain!

• Free as in Freedom (Sam Williams, 2002): Free-licensed official biography of Richard Stallman, contains many historical details about how free software came to be, how open source spoiled it etc.

• Free Culture (Lessig, 2004): Creative-commons licensed (non-free but gratis) book by the founder of Creative Commons and free cutlure, goes into details on how copyright became abused by capitalism, why public domain is being smothered and why we must support free culture.

• Game Engine Black Book: Doom (Sanglard, 2019): Gratis, very nice book dissecting all the details about the legendary Doom engine and its internals -- how it worked, why was it so fast, what hacks went into it, written so that a reader of any programming skill (even none) will find something interesting. A must read for fans of oldschool game programming.

• Game Engine Black Book: Wolfenstein 3D (Sanglard, 2019): Same as the Doom engine book from the same author, just about the older game Wolfenstein 3D, also amazing.

• Industrial Society and Its Future (Kaczynski, 1995): A bit boring read by the famous Unabomber, criticizing rapid technology advancement, but an important read for those who are more into politics, if only for the memes :)

• ISO/IEC 9899:1999 (1999): Specification of the version of C programming language that suckless/LRS very often uses. It's nice to skim over it to get an idea how a language is actually specified. You'll also probably learn something new about C in the process.

• Just for Fun (2001): Official biography of Linux Torvalds, the original creator of Linux. It recounts valuable historical moments with comments by Linus himself, revealing many interesting details and also a bit of Torvalds' personality (shows some of his evil side).

• Larousse Desk Reference Encyclopedia (1995): Very nice single-volume encyclopedia that's sorted by topic, with many nice illustrations, published back then when censorship wasn't so extreme, provides overview of all topics of human knowledge.

• Masters of Doom (Kushner, 2003): Another nice book for Doom 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 (1975...): Hacker culture 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" 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.

• 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.

• older books by Andreas Eschbach { The new ones seemed to have some Feminist shit etc., had to stop reading it :D ~drummyfish }, mainly Carpet Makers and Jesus Video: This is not directly related to LRS but it feels right to mention one of the most underrated sci-fi authors here -- many LRS followers will probably appreciate high quality sci-fi dealing with super interesting topics that are at least loosely related to LRS. Really Eschbach is so superior to just 99% of all sci-fi you'll encounter, his books are extremely readable, believable and greatly interesting in choosing topics, he makes you think about society, religion etcetc. Spoilers probably won't help, just go check out the books.

• The Pig and the Box (MCM, 2009): A short story for kids showing the dangers of DRM, released under CC0!

• The Tao of Programming (James, 1987): Famous piece of hacker culture literature, wisdom of programming written in taoist style.

• Tricks of the Game Programming Gurus (1994): Very nice, readable book, that implements a whole 90s shooter game in C, without drowning the reader in tons of equations and smartass talk. It's written with the 90s mindset and in common language, contains many practical tricks for optimizing the code etc.

• ...

{ TODO (have to read first): Lisp From Nothing (implementing minimal self-hosted Lisp, CC0 code!). ~drummyfish }

Boot

See bootstrapping.

Bootstrap/Boot

In general bootstrapping (from the idiom "pull yourself up by your bootstraps"), sometimes shortened to just booting, refers to a clever process of self-establishing some relatively complex system starting from something very small, without much external help. As an example imagine something like a "civilization bootstrapping kit" that contains only few primitive tools along with instructions on how to use those tools to mine ore, turn it into metal out of which one makes more tools which will be used to obtain more material and so on up until having basically all modern technology and factories set up in relatively short time (civboot is a project like this). The term bootstrapping is however especially relevant in relation to computer technology -- here it has two main meanings:

• The process by which a computer starts and sets up the operating system after power on, which often involves several stages of loading various modules, running several bootloaders etc. This is traditionally called booting (rebooting means restarting the computer).
• Utilizing the principle of bootstrapping for making greatly independent software, i.e. software that doesn't depend on other software as it can set itself up. This is usually what bootstrapping (the longer term) means. This is also greatly related to self hosting, another principle whose idea is to "implement technology using itself".

Bootstrapping: Making Dependency-Free Software

Bootstrapping as a general principle can aid us in creation of extremely free technology by greatly minimizing all its dependencies, we are able to create a small amount of code that will self-establish our whole computing environment with only very small effort during the process. The topic mostly revolves around designing programming language compilers, but in general we may be talking about bootstrapping whole computing environments, operating systems etc.

Why be concerned with bootstrapping when we already have our systems set up? There are many reasons, one of the notable ones is that we may lose our current technology due to societal collapse, which is not improbable, it keeps happening throughout history over and over, so many people fear (rightfully so) that if by whatever disaster we lose our current computers, Internet etc., we will also lose with it all modern art, data, software we so painfully developed, digitized books, inventions and so on; not talking about the horrors that will follow if we're unable to quickly reestablish our computer networks we are so dependent on. Setting up what we currently have completely from scratch would be extremely difficult, a task for centuries -- just take a while to consider all the activity and knowledge that's required around the globe to create a single computer with all its billions of lines of code worth of software that makes it work. Knowledge of old technology gets lost -- to make modern computers we first needed older, primitive computers, but now that we only have modern computers no one remembers anymore how to make the older computers -- if we lose the current ones, we won't be able to make them, we will lack the tools. Another reason for bootstrapping is independence of technology which brings e.g. freedom (your operating system being able to be set up anywhere without some corporation's proprietary driver or hardware unit is pursued by many), robustness, simplicity, ability to bring existing software to new platforms and so on, i.e. things that are practical even in current world.

Forth has traditionally been used for making bootstrapping environments; Dusk OS is an example of such project. Similarly simple language such as Lisp and comun will probably work too.

How to do this then? To make a computing environment that can bootstrap itself you can do it like this:

1. Make a simple programming language L. You can choose e.g. the mentioned Forth but you can even make your own, just remember to keep it extremely simple -- simplicity of the base language is the key feature here. The language will serve as tool for writing software for your platform, i.e. it will provide some comfort in programming (so that you don't have to write in assembly) but mainly it will be an abstraction layer for the programs, it will allow them to run on any hardware/platform. The language therefore has to be portable; it should probably abstracts things like endianness, native integer size, control structures etc., so as to work nicely on all CPUs, but it also mustn't have too much abstraction (such as OOP) otherwise it will quickly get complicated. The language can compile e.g. to some kind of very simple bytecode that will be easy to translate to any assembly. At first you'll have to temporarily implement L in some already existing language, e.g. C. NOTE: in theory you could just make bytecode, without making L, and just write your software in that bytecode, but the bytecode has to focus on being simple to translate, i.e. it will e.g. likely have few opcodes, which will be in conflict with making it at least somewhat comfortable to program on your platform. However one can try to make some compromise and it will save the complexity of translating language to bytecode, so it can be considered (uxn seems to be doing this).
2. Write L in itself, i.e. self host it. This means you'll use L to write a compiler of L that outputs L's bytecode. Once you do this, you have a completely independent language and can throw away the original compiler of L written in another language. Now compile L with itself -- you'll get the bytecode of L compiler. At this point you can bootstrap L on any platform as long as you can execute the L bytecode on it -- this is why it was crucial to make L and its bytecode very simple. In theory it's enough to just interpret the bytecode but it's better to translate it to the platform's native machine code so that you get maximum efficiency (the nature of bytecode should make it so that it isn't really more diffiult to translate it than to interpret it). If for example you want to bootstrap on an x86 CPU, you'll have to write a program that translates the bytecode to x86 assembly; if we suppose that at the time of bootstrapping you will only have this x86 computer, you will have to write the translator in x86 assembly manually. If your bytecode really is simple and well made, it shouldn't be hard though (you will mostly be replacing your bytecode opcodes with given platform's machine code opcodes).
3. Further help make L bootstrapable. This means making it even easier to execute the L bytecode on any given platform -- you may for example write the bytecode translators for common platforms like x86, ARM, RISC-V and so on. At this point you have L bootstrappable without any work on the platform you have translators for and on others it will just take a tiny bit of work to write its own translator.
4. Write everything else in L. This means writing the platform itself and software such as various tools and libraries. You can potentially even use L to write a higher level language for yet more comfort in programming. Since everything here is written in L and L can be bootstrapped, everything here can be bootstrapped as well.

Booting: Computer Starting Up

Booting as in "staring computer up" is also a kind of setting up a system from the ground up -- we take it for granted but remember it takes some work to get a computer from being powered off and having all RAM empty to having an operating system loaded, hardware checked and initialized, devices mounted etc.

Starting up a simple computer -- such as some MCU-based embedded open console that runs bare metal programs -- isn't as complicated as booting up a mainstream PC with an operating system.

First let's take a look at the simple computer. It may work e.g. like this: upon start the CPU initializes its registers and simply starts executing instructions from some given memory address, let's suppose 0 (you will find this in your CPU's data sheet). Here the memory is often e.g. flash ROM to which we can externally upload a program from another computer before we turn the CPU on -- in game consoles this can often be done through USB. So we basically upload the program (e.g. a game) we want to run, turn the console on and it starts running it. However further steps are often added, for example there may really be some small, permanently flashed initial boot program at the initial execution address that will handle some things like initializing hardware (screen, speaker, ...), setting up interrupts and so on (which otherwise would have to always be done by the main program itself) and it can also offer some functionality, for example a simple menu through which the user can select to actually load a program from SD card to flash memory (thanks to which we won't need external computer to reload programs). In this case we won't be uploading our main program to the initial execution address but rather somewhere else -- the initial bootloader will jump to this address once it's done its work.

Now for the PC (the "IBM compatibles"): here things are more complicated due to the complexity of the whole platform, i.e. because we have to load an operating system first, of which there can be several, each of which may be loadable from different storages (harddisk, USB stick, network, ...), also we have more complex CPU that has to be set in certain operation mode, we have complex peripherals that need complex initializations etcetc. Generally there's a huge bloated boot sequence and PCs infamously take longer and longer to start up despite skyrocketing hardware improvements -- that says something about state of technology. Anyway, it usually it works like this:

{ I'm not terribly experienced with this, verify everything. ~drummyfish }

1. Computer is turned on, the CPU starts executing at some initial address (same as with the simple computer).
2. From here CPU jumps to an address at which stage one bootloader is located (bootloader is just a program that does the booting and as this is the first one in a line of potentially multiple bootloaders, it's called stage one). This address is in the motherboard ROM and in there typically BIOS (or something similar that may be called e.g. UEFI, depending on what standard it adheres to) is uploaded, i.e. BIOS is stage one bootloader. BIOS is the first software (we may also call it firmware) that gets run, it's uploaded on the motherboard by the manufacturer and isn't supposed to be rewritten by the user, though some based people still rewrite it (ignoring the "read only" label :D), often to replace it with something more free (e.g. libreboot). BIOS is the most basic software that serves to make us able to use the computer at the most basic level without having to flash programs externally, i.e. to let us use keyboard and monitor, let us install an operating system from a CD drive etc. (It also offers a basic environment for programs that want to run before the operating system, but that's not important now.) BIOS is generally different on each computer model, it normally allows us to set up what (which device) the computer will try to load next -- for example we may choose to boot from harddisk or USB flash drive or from a CD. There is often some countdown during which if we don't intervene, the BIOS automatically tries to load what's in its current settings. Let's suppose it is set to boot from harddisk.
3. BIOS performs the power on self test (POST) -- basically it makes sure everything is OK, that hardware works etc. If it's so, it continues on (otherwise halts).
4. BIOS loads the master boot record (MBR, the first sector of the device) from harddisk (or from another mass storage device, depending on its settings) into RAM and executes it, i.e. it passes control to it. This will typically lead to loading the second stage bootloader.
5. The code loaded from MBR is limited by size as it has to fit in one HDD sector (which used to be only 512 bytes for a long time), so this code is here usually just to load the bigger code of the second stage bootloader from somewhere else and then again pass control to it.
6. Now the second stage bootloader starts -- this is a bootloader whose job it is normally to finally load the actual operating system. Unlike BIOS this bootloader may quite easily be reinstalled by the user -- oftentime installing an operating system will also cause installing some kind of second stage bootloader -- example may be GRUB which is typically installed with GNU/Linux systems. This kind of bootloader may offer the user a choice of multiple operating systems, and possibly have other settings. In any case here the OS kernel code is loaded and run.
7. Voila, the kernel now starts running and here it's free to do its own initializations and manage everything, i.e. Linux will start the PID 1 process, it will mount filesystems, run initial scripts etcetc.

Brainfuck

Brainfuck is an extremely simple, minimalist untyped esoteric programming language; simple by its specification (consisting only of 8 commands) but very hard to program in (it is so called Turing tarpit). It works similarly to a pure Turing machine. In a way it is kind of beautiful by its simplicity, it is very easy to write your own brainfuck interpreter (or compiler) -- in fact the Brainfuck author's goal was to make a language for which the smallest compiler could be made.

There exist self-hosted Brainfuck interpreters and compilers (i.e. themselves written in Brainfuck) which is pretty fucked up. The smallest one is probably the one called dbfi which has only slightly above 400 characters, that's incredible!!! (Esolang wiki states that it's one of the smallest self interpreters among imperative languages). Of course, Brainfuck quines (programs printing their own source code) also exist, but it's not easy to make them -- one example found on the web was a little over 2100 characters long.

The language is based on a 1964 language P´´ which was published in a mathematical paper; it is very similar to Brainfuck except for having no I/O. Brainfuck itself was made in 1993 by Urban Muller, he wrote a compiler for it for Amiga, which he eventually managed to get under 200 bytes.

Since then Brainfuck has seen tremendous success in the esolang community as the lowest common denominator language: just as mathematicians use Turing machines in proofs, esolang programmers use brainfuck in similar ways -- many esolangs just compile to brainfuck or use brainfuck in proofs of Turing completeness etc. This is thanks to Brainfuck being an actual, implemented and working language with I/O and working on real computers, not just some abstract mathematical model. For example if one wants to encode a program as an integer number, we can simply take the binary representation of the program's Brainfuck implementation. Brainfuck also has many derivatives and modifications (esolang wiki currently lists over 600 such languages), e.g. Brainfork (Brainfuck with multithreading), Boolfuck (has only binary cells), Brainfuck++ (adds more features like networking), Pi (encodes Brainfuck program in error agains pi digits), Unary (encodes Brainfuck with a single symbol) etcetc.

In LRS programs brainfuck may be seriously used as a super simple scripting language.

Brainfuck can be trivially translated to comun like this: remove all comments from brainfuck program, then replace +, -, >, <, ., ,, [ and ] with ++ , -- , $>0 , $<0 , ->' , $<0 <- , @' and . , respectively, and prepend $>0 .

Specification

The "vanilla" brainfuck operates as follows:

We have a linear memory of cells and a data pointer which initially points to the 0th cell. The size and count of the cells is implementation-defined, but usually a cell is 8 bits wide and there is at least 30000 cells.

A program consists of these possible commands:

• +: increment the data cell under data pointer
• -: decrement the data cell under data pointer
• >: move the data pointer to the right
• <: move the data pointer to the left
• [: jump after corresponding ] if value under data pointer is zero
• ]: jump after corresponding [ if value under data pointer is not zero
• .: output value under data pointer as an ASCII character
• ,: read value and store it to the cell under data pointer

Characters in the source code that don't correspond to any command are normally ignored, so they can conveniently be used for comments.

Brainfuck source code files usually have .bf or .b extension.

Implementation

This is a very simple C implementation of brainfuck:

#include <stdio.h>

#define CELLS 30000

const char program[] = ",[.-]"; // your program here

int main(void)
{
  char tape[CELLS];
  unsigned int cell = 0;
  const char *i = program;
  int bDir, bCount;
  
  while (*i != 0)
  {
    switch (*i)
    {
      case '>': cell++; break;
      case '<': cell--; break;
      case '+': tape[cell]++; break;
      case '-': tape[cell]--; break;
      case '.': putchar(tape[cell]); fflush(stdout); break;
      case ',': scanf("%c",tape + cell); break;
      case '[':
      case ']':
        if ((tape[cell] == 0) == (*i == ']'))
          break;

        bDir = (*i == '[') ? 1 : -1;
        bCount = 0;
          
        while (1)
        {
          if (*i == '[')
            bCount += bDir;
          else if (*i == ']')
            bCount -= bDir;
          
          if (bCount == 0)
            break;
          
          i += bDir;
        }
        
        break;
      
      default: break;
    }
    
    i++;
  }
}

TODO: comun implementation

Programs

Here are some simple programs in brainfuck.

Print HI:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ . + .

Read two 0-9 numbers (as ASCII digits) and add them:

,>,[<+>-]<------------------------------------------------.

TODO: more

Variants

TODO

See Also

• False (a very similar esolang)
• comun

Brain Software

Brain software, also brainware, is kind of a fun idea of software that runs on the human brain as opposed to a typical electronic computer. This removes the dependency on computers and highly increases freedom. Of course, this also comes with a huge drop of computational power :) However, aside from being an entertaining idea to explore, this kind of software and "architectures" may become interesting from the perspective of freedom and primitivism (especially when the technological collapse seems like a real danger).

Primitive tools helping the brain compute, such as pen and paper or printed out mathematical tables, may be allowed.

Example of brain software can be the game of chess. A chess master can easily play the game without a physical chess board, only in his head, and he can play games with someone else just by saying the moves out loud. He may even just play games with himself, which makes chess a deep, entertaining game that can be 100% contained in one's brain. Such game can never be taken away from the man, it can't be altered by corporations, it can't become unplayable on new hardware etc., making it free to the greatest extent. Many other board games and pen and pencil games, such as racetrack (pen and pencil racing game suitable for one or many players).

One may think of a pen and paper computer with its own simple instruction set that allows general purpose programming. This instruction set may be designed to be well interpretable by human and it may be accompanied by tables printed out on paper for quick lookup of operation results -- e.g. a 4 bit computer might provide a 16x16 table with precomputed multiplication results which would help the individual execute the multiplication instruction within mere seconds.

Yet another idea is to make a computer with architecture similar to the typical electronic computers but powered by human brains -- let's call this a human computer (not to be confused with people whose job was to perform computations!). Imagine that after a societal collapse we lose our computer technology (i.e. the ability to manufacture transistors and similar key components), but we retain our knowledge of computer architecture, algorithms and the usefulness of computers. As a temporary solution for performing computations we may create a "computer made of humans", a room with several men, each one performing a role of some computer component, for example an ALU, cache and memory controller. Again, a special instruction set and a set of tools (such as physical lookup tables for results of instructions) could be made to make such a human computer relatively fast. It might not run Doom, but it could possibly e.g. compute some mathematical constants to a high precision or perhaps help find optimal structure of cities, compute stresses in big building etc. In such conditions even a slow calculator could be immensely useful.

BS

Bullshit.

Build Engine

For now see Duke Nukem.

Bullshit

Bullshit (BS) is nonsense, arbitrary unnecessary shit and/or something made up only out of necessity. Typical example are e.g. so called bullshit jobs -- jobs that are arbitrarily created just to keep people employed and don't actually serve anything else.

Simplified example of capitalist bullshit: under capitalism basically the whole society is based on bullshit of many kinds, small and big, creating many bullshit clusters that are all intertwined and interact in complex ways, creating one huge bullshit. For simplicity let's consider an educational isolated bullshit cluster (that we won't see that often in reality), a hypothetical car factory. No matter how the factory came to be, it now ended up making cars for people so that these people can drive to work at the car factory to make more cars for other people who will work to the car factory to make cars etc. -- a bullshit cycle that exists just for its own sake, just wastes natural resources and lives of people. Of course at one point all the factory employees will own a car and the factory will have no more demand for the cars, which threatens its existence. Here capitalism employs adding more bullshit: let's say they create new bullshit jobs they call something like "smart car research center" -- this will create new work position, i.e. more people who will need cars to drive to work, but MAINLY the job of these people will be adding artificial obsolescence to the cars, which will make them last much shorter time and regularly break so that they will need repairs using parts manufactured at the factory, creating more work that will need to be done and more bullshit jobs in the car repair department. Furthermore the team will make the cars completely dependent on subscription software, employing consumerism, i.e. the car will no longer be a "buy once" thing but rather something one has to keep feeding constantly (fuel, software subscription, insurance, repairs, cleaning, tire changes, and of course once in a few years just buying a new non-obsolete model), so that workers will still need to drive to work every day, perpetuating their need for being preoccupied with owning and maintaining a car. This is a bullshit cluster society could just get rid of without any cost, on the contrary it would gain many free people who could do actually useful things like curing diseases, eliminating world hunger, creating art for others to enjoy. However if you tell a capitalist any part of this system is bullshit, he will defend it by its necessity in the system as a whole ("How will people get to work without cars?!", "Factories are needed for the economy!", "Economy is needed to drive manufacturing of cars!") -- in reality the bullshit clusterfuck spans the whole world to incredibly deep levels so you just can't make many people see it, especially when they're preoccupied with maintaining their own existence and just get by within it.

Some things that are bullshit include:

• anticheat
• antiviruses
• army
• bureaucracy
• capitalism
• censorship
• clothes
• consumerism
• countries
• crypto
• disclaimers
• DRM
• economy
• management
• fashion
• "game design" (it's just part of programming games)
• gender studies
• guns
• insurance
• jobs
• law
• licenses
• "life coaching" lmao
• market
• marketing, ads
• money
• police
• political correctness
• prisons
• privacy
• productivity
• property (including copyright etc.)
• security
• states
• UML
• unions
• wars
• Anything justified by "economy needing it" is 100% pure bullshit.
• ...

OK then, what's not bullshit? Well, things that matter, for example food, health, education, love, fun, art, technology, knowledge about the world, science, morality, exploration, ...

Bytebeat

Bytebeat is a procedural chiptune/8bit style music generated by a short expression in a programming language; it was discovered/highlighted in 2011 by Viznut (author of countercomplex blog) and others, and the technique capable of producing quite impressive music by single-line code has since caught the attention of many programmers, especially in demoscene. There has even been a paper written about bytebeat. Bytebeat can produce music similar (though a lot simpler) to that created e.g. with music trackers but with a lot less complexity and effort.

This is a beautiful hack for LRS/suckless programmers because it takes quite a tiny amount of code, space and effort to produce nice music, e.g. for games (done e.g. by Anarch).

8bit samples corresponding to unsigned char are typically used with bytebeat. The formulas take advantage of overflows that create rhythmical patterns with potential other operations such as multiplication, division, addition, squaring, bitwise/logical operators and conditions adding more interesting effects.

Bytebeat also looks kind of cool when rendered as an image (outputting pixels instead of audio samples).

How To

Quick experiments with bytebeat can be performed with online tools that are easy to find on the web, these usually use JavaScript.

Nevertheless, traditionally we use C for bytebeat. We simply create a loop with a time variable (i) and inside the loop body we create our bytebeat expression with the variable to compute a char that we output.

A simple "workflow" for bytebeat "development" can be set up as follows. Firstly write a C program:

#include <stdio.h>

int main(void)
{
  for (int i = 0; i < 10000; ++i)
    putchar(
      i / 3 // < bytebeat formula here
    );

  return 0;
}

Now compile the program and play its output e.g. like this:

gcc program.c && ./a.out | aplay

Now we can just start experimenting and invent new music by fiddling with the formula indicated by the comment.

General tips/tricks and observations are these:

• Outputting the variable i creates a periodical saw-shaped beat, multiplication/division decreases/increases the speed, addition/subtraction shifts the phase backward/forward.
• Squaring (and other powers) create a wah-wah effect.
• Crazier patterns can be achieved by using the variable in places of numerical constants, e.g. i << ((i / 512) % 8) (shifting by a value that depends on the variable).
• Modulo (%) increases the frequency and decreases volume (limits the wave peak).
• So called Sierpinski harmonies are often used melodic expressions of the form i*N & i >> M.
• Bitwise and (&) can add distortion (create steps in the wave).
• A macro structure of the song (silent/louds parts, verse/chorus, ...) can be achieved by combining multiple patterns with some low-frequency pattern, e.g. this alternates a slower and faster beat: int cond = (i & 0x8000) == 0;, cond * (i / 16) + !cond * (i / 32)
• Extra variables can add more complexity (e.g. precompute some variable a which will subsequently be used multiple times in the final formula).

Copyright

It is not exactly clear whether, how and to what extent copyright can apply to bytebeat: on one hand we have a short formula that's uncopyrightable (just like mathematical formulas), on the other hand we have music, an artistic expression. Many authors of bytebeat "release" their creations under free licenses such as CC-BY-SA, but such licenses are of course not applicable if copyright can't even arise.

We believe copyright doesn't and SHOULDN'T apply to bytebeat. To ensure this, it is good to stick CC0 to any released bytebeat just in case.

Examples

A super-simple example can be just a simple:

• i / 16

The following more complex examples come from the LRS game Anarch (these are legally safe even in case copyright can apply to bytebeat as Anarch is released under CC0):

• distortion guitar rhythmical beat: ~((((i >> ((i >> 2) % 32)) | (i >> ((i >> 5) % 32))) & 0x12) << 1) | (i >> 11)
• electronic/techno: ((0x47 >> ((i >> 9) % 32)) & (i >> (i % 32))) | (0x57 >> ((i >> 7) % 32)) | (0x06 >> ((i >> ((((i * 11) >> 14) & 0x0e) % 32)) % 32))
• main theme, uses an extra variable: (((i) & 65536) ? (a & (((i * 2) >> 16) & 0x09)) : ~a), where uint32_t a = ((i >> 7) | (i >> 9) | (~i << 1) | i)

Here is an ASCII visualization of the first track:

,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
M'''''''''''''''M'''''''''''''''k'M'''''''''''''k'M'''''''''''''
c;xxxxxxxxxxxxxxc;cxxxxxxxxxxxxx,;xxxxxxxxxxxxxx,;cxxxxxxxxxxxxx
. ;.:;;;;;;;;;;;. ;.:;;;;;;;;;;;0 . :;;;;;;;;;;;0 . :;;;;;;;;;;;
okokokkkkkkkkkkklklkokkkkkkkkkkkokokokkkkkkkkkkklklkokkkkkkkkkkk
xkX0000000000000ckX0000000000000xkXK000000000000ckXK000000000000
oMKMKMMMMMMMMMMMlMkMKMMMMMMMMMMMoMKMKMMMMMMMMMMMlMkMKMMMMMMMMMMM
xK00KWWWWWWWWWWWcKX0KWWWWWWWWWWWxK0KKWWWWWWWWWWWcKXKKWWWWWWWWWWW
xMWMWMWWWWWWWWWWxMWMWMWWWWWWWWWWx0W0WMWWWWWWWWWWx0W0WMWWWWWWWWWW
xMWMWMWWWWWWWWWWxMWMWMWWWWWWWWWWx0W0WMWWWWWWWWWWx0W0WMWWWWWWWWWW
xMMMMMWWWWWWWWWWxMMMMMWWWWWWWWWWx0M0MMWWWWWWWWWWx0M0MMWWWWWWWWWW
xMMMMMWWWWWWWWWWxMMMMMWWWWWWWWWWx0M0MMWWWWWWWWWWx0M0MMWWWWWWWWWW
xMWcWWWWWWWWWWWWxlWcWWWWWWWWWWWWxMWcWWWWWWWWWWWWxlWcWWWWWWWWWWWW
xMccWWWWWWWWWWWWxlccWWWWWWWWWWWWxMccWWWWWWWWWWWWxlccWWWWWWWWWWWW
xMWcWWWWWWWWWWWWxlWcWWWWWWWWWWWWxMWcWWWWWWWWWWWWxlWcWWWWWWWWWWWW
xMccWWWWWWWWWWWWxlccWWWWWWWWWWWWxMccWWWWWWWWWWWWxlccWWWWWWWWWWWW
xMWWWWWWWWWWWWWWxMWWWWWWWWWWWWWWxMXWWWWWWWWWWWWWxMXWWWWWWWWWWWWW
xMWWWWWWWWWWWWWWxMWWWWWWWWWWWWWWxMXWWWWWWWWWWWWWxMXWWWWWWWWWWWWW
xMWXWWWWWWWWWWWWxMWXWWWWWWWWWWWWxMXXWWWWWWWWWWWWxMXXWWWWWWWWWWWW
xMWXWWWWWWWWWWWWxMWXWWWWWWWWWWWWxMXXWWWWWWWWWWWWxMXXWWWWWWWWWWWW
xMWW00WWWWWWWWWWxM0W00WWWWWWWWWWxMWW00WWWWWWWWWWxM0W00WWWWWWWWWW
xMW000WWWWWWWWWWxM0000WWWWWWWWWWxMW000WWWWWWWWWWxM0000WWWWWWWWWW
xMWW00WWWWWWWWWWxM0W00WWWWWWWWWWxMWW00WWWWWWWWWWxM0W00WWWWWWWWWW
xMW000WWWWWWWWWWxM0000WWWWWWWWWWWWW000WWWWWWWWWWWW0000WWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWMWWWWWWWWWWWWWMWMWWWWWWWWWWWWWMWMWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWMWWWWWWWWWWWWWMWMWWWWWWWWWWWWWMWMWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWMMWWWWWWWWWWWWWMMMWWWWWWWWWWWWWMMMWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWMMWWWWWWWWWWWWWMMMWWWWWWWWWWWWWMMMWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
MM''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
ccccxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
..::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ooookkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
xxKKKK0000000000000000000000000000000000000000000000000000000000
ooKKMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxKKMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxxxxxxxKKKKKKKKMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxxxxxxxKKKKKKKKMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxxxxxxxKKKKKKKKMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
xxxxxxxxKKKKKKKKMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

See Also

• music tracker
• databending
• MIDI
• beatbox
• animalese / beep speech

Bytecode

Bytecode (BC, also P-code, "portable code") is a type of binary format for executable programs usually intended to be interpreted or to serve as an intermediate representation in compilers (i.e. meant to be translated to some other language); it is quite similar to machine code, however machine code is meant to be directly run by some physical hardware while bytecode is more of a virtual, machine independent code preferring things like portability, speed of interpretation, retaining meta information or being easy to translate.

TODO: moar

Example

Let's consider a simple algorithm that tests the Collatz conjecture (which says that applying a simple operation from any starting number over and over will always lead to number 1). The program reads a number (one digit for simplicity) and then prints the sequence until reaching the final number 1. The algorithm in C would look as follows:

// Collatz conjecture
#include <stdio.h>

int next(int n)
{
  return n % 2 ? // is odd?
    3 * n + 1 :
    n / 2;
}

int main(void)
{
  int n = getchar() - '0'; // read input ASCII digit

  while (1)
  {
    printf("%d\n",n);

    if (n == 1)
      break;

    n = next(n);
  }

  return 0;
}

C will be normally compiled to machine code, however we can take a look at some immediate representation bytecode that compilers internally use to generate the machine code. The following is LLVM, a widely used bytecode that can be produced from the above C code with clang compiler (e.g. as clang -cc1 tmp.c -S -emit-llvm -o -):

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"

@.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1

; Function Attrs: noinline nounwind optnone
define i32 @next(i32 %n) #0 {
entry:
  %n.addr = alloca i32, align 4
  store i32 %n, i32* %n.addr, align 4
  %0 = load i32, i32* %n.addr, align 4
  %rem = srem i32 %0, 2
  %tobool = icmp ne i32 %rem, 0
  br i1 %tobool, label %cond.true, label %cond.false

cond.true:                                  ; preds = %entry
  %1 = load i32, i32* %n.addr, align 4
  %mul = mul nsw i32 3, %1
  %add = add nsw i32 %mul, 1
  br label %cond.end

cond.false:                                 ; preds = %entry
  %2 = load i32, i32* %n.addr, align 4
  %div = sdiv i32 %2, 2
  br label %cond.end

cond.end:                                   ; preds = %cond.false, %cond.true
  %cond = phi i32 [ %add, %cond.true ], [ %div, %cond.false ]
  ret i32 %cond
}

; Function Attrs: noinline nounwind optnone
define i32 @main() #0 {
entry:
  %retval = alloca i32, align 4
  %n = alloca i32, align 4
  store i32 0, i32* %retval, align 4
  %call = call i32 (...) @getchar()
  %sub = sub nsw i32 %call, 48
  store i32 %sub, i32* %n, align 4
  br label %while.body

while.body:                                 ; preds = %entry, %if.end
  %0 = load i32, i32* %n, align 4
  %call1 = call i32 (i8*, ...) @printf(i8* ... )
  %1 = load i32, i32* %n, align 4
  %cmp = icmp eq i32 %1, 1
  br i1 %cmp, label %if.then, label %if.end

if.then:                                    ; preds = %while.body
  br label %while.end

if.end:                                     ; preds = %while.body
  %2 = load i32, i32* %n, align 4
  %call2 = call i32 @next(i32 %2)
  store i32 %call2, i32* %n, align 4
  br label %while.body

while.end:                                  ; preds = %if.then
  ret i32 0
}

declare i32 @getchar(...) #1

declare i32 @printf(i8*, ...) #1

attributes #0 = { ... }
attributes #1 = { ... }

!llvm.module.flags = !{!0}
!llvm.ident = !{!1}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{!"clang version 7.0.1-8+deb10u2 (tags/RELEASE_701/final)"}

TODO: analyze the above

Now let's rewrite the same algorithm in comun, a different language which will allow us to produce another kind of bytecode (obtained with comun -T program.cmn):

# Collatz conjecture

next:
  $0 2 % ? # is odd?
    3 * 1 +
  ;
    2 /
  .
.

<-     # read input ASCII digit
"0" -  # convert it to number

@@
  # print:
  $0 10 / "0" + ->
  $0 10 % "0" + ->
  10 ->

  $0 1 = ?
    !@
  .
 
  next
.

Here is annotated comun bytecode this compiles to:

000000: DES  00 0111    # func      \ next:
000001: JMA  00 0100... # 20 (#14)   |
000002: COC  00 0001                 |
000003: MGE  00 0000                 | $0
000004: CON' 00 0010    # 2 (#2)     | 2 
000005: MOX  00 0000                 | %
000006: DES  00 0001    # if         | \ ?
000007: JNA  00 0000... # 16 (#10)   |  |
000008: COC  00 0001                 |  |
000009: CON' 00 0011    # 3 (#3)     |  | 3
00000a: MUX  00 0000                 |  | *
00000b: CON' 00 0001    # 1 (#1)     |  | 1
00000c: ADX  00 0000                 |  | +
00000d: DES  00 0010    # else       | < ;
00000e: JMA  00 0011... # 19 (#13)   |  |
00000f: COC  00 0001                 |  |
000010: CON' 00 0010    # 2 (#2)     |  | 2
000011: DIX  00 0000                 |  | /
000012: DES  00 0011    # end if     | / .
000013: RET  00 0000                / .
000014: INI  00 0000
000015: INP  00 0000                <-
000016: CON' 00 0000... # 48 (#30)  "0"
000017: COC  00 0011
000018: SUX  00 0000                -
000019: DES  00 0100    # loop      \ @@
00001a: MGE  00 0000                 | $0
00001b: CON' 00 1010    # 10 (#a)    | 10
00001c: DIX  00 0000                 | /
00001d: CON' 00 0000... # 48 (#30)   | "0"
00001e: COC  00 0011                 |
00001f: ADX  00 0000                 | +
000020: OUT  00 0000                 | ->
000021: MGE  00 0000                 | $0
000022: CON' 00 1010    # 10 (#a)    | 10
000023: MOX  00 0000                 | %
000024: CON' 00 0000... # 48 (#30)   | "0"
000025: COC  00 0011                 |
000026: ADX  00 0000                 | +
000027: OUT  00 0000                 | ->
000028: CON' 00 1010    # 10 (#a)    | 10
000029: OUT  00 0000                 | ->
00002a: MGE  00 0000                 | $0
00002b: CON' 00 0001    # 1 (#1)     | 1
00002c: EQX  00 0000                 | =
00002d: DES  00 0001    # if         | \ ?
00002e: JNA  00 0100... # 52 (#34)   |  |
00002f: COC  00 0011                 |  |
000030: DES  00 0101    # break      |  | !@
000031: JMA  00 1000... # 56 (#38)   |  |
000032: COC  00 0011                 |  |
000033: DES  00 0011    # end if     | / .
000034: CAL  00 0011    # 3 (#3)     | next
000035: DES  00 0110    # end loop  / .
000036: JMA  00 1010... # 26 (#1a)
000037: COC  00 0001
000038: END  00 0000

TODO: analyze the above, show other bytecodes (python, java, ...)

Let's try the same in Python. The code we'll examine will look like this:

# Collatz conjecture

def next(n):
  return 3 * n + 1 if n % 2 != 0 else n / 2

n = ord(raw_input()[0]) - ord('0')

while True:
  print(n)

  if n == 1:
    break

  n = next(n)

And the bytecode we get (e.g. with python -m dis program.py):

 3       0 LOAD_CONST           0 (<code object next at ...)
         3 MAKE_FUNCTION        0
         6 STORE_NAME           0 (next)

 6       9 LOAD_NAME            1 (ord)
        12 LOAD_NAME            2 (raw_input)
        15 CALL_FUNCTION        0
        18 LOAD_CONST           1 (0)
        21 BINARY_SUBSCR       
        22 CALL_FUNCTION        1
        25 LOAD_NAME            1 (ord)
        28 LOAD_CONST           2 ('0')
        31 CALL_FUNCTION        1
        34 BINARY_SUBTRACT     
        35 STORE_NAME           3 (n)

 8      38 SETUP_LOOP          43 (to 84)
    >>  41 LOAD_NAME            4 (True)
        44 POP_JUMP_IF_FALSE   83

 9      47 LOAD_NAME            3 (n)
        50 PRINT_ITEM          
        51 PRINT_NEWLINE       

11      52 LOAD_NAME            3 (n)
        55 LOAD_CONST           3 (1)
        58 COMPARE_OP           2 (==)
        61 POP_JUMP_IF_FALSE   68

12      64 BREAK_LOOP          
        65 JUMP_FORWARD         0 (to 68)

14  >>  68 LOAD_NAME            0 (next)
        71 LOAD_NAME            3 (n)
        74 CALL_FUNCTION        1
        77 STORE_NAME           3 (n)
        80 JUMP_ABSOLUTE       41
    >>  83 POP_BLOCK       
    >>  84 LOAD_CONST           4 (None)
        87 RETURN_VALUE

TODO: make sense of it and analyze it

TODO: web assembly

Byte

Byte (symbol: B) is a basic unit of information, nowadays already practically always consisting of 8 bits (for which it's also called an octet), that allow it to store 2^8 = 256 distinct values (for example a number in range 0 to 255). It is commonly the smallest unit of computer memory a CPU is able to operate on; memory addresses are assigned by steps of one byte. We use bytes to measure the size of memory and derive higher memory units such as a kilobyte (kB, 1000 bytes), kibibyte (KiB, 1024 bytes), megabyte (MB, 10^6 bytes) and so forth. In conventional programming a one byte variable is seen as very small and used if we are really limited by memory constraints (e.g. embedded) or to mimic older 8bit computers ("retro games" etc.): one byte can be used to store very small numbers (while in mainstream processors numbers nowadays mostly have 4 or 8 bytes), text characters (ASCII, ...), very primitive colors (see RGB332, palettes, ...) etc.

Historically byte was used to stand for the basic addressable unit of memory capable of storing one text character or another "basic value" and could therefore have a different size than 8 bits: for example ASCII machines might have had a 7bit byte, 16bit machines a 16bit byte etc.; in C (standard 99) char is the "byte" data type, its byte size is always 1 (sizeof(char) == 1), though its number of bits (CHAR_BIT) can be greater or equal to 8; if you need an exact 8bit byte use types such as int8_t and uint8_t from the standard stdint library. From now on we will implicitly talk about 8bit bytes.

Value of one byte can be written exactly with two hexadecimal digits with each digit always corresponding to higher/lower 4 bits, making mental conversions very easy; this is very convenient compared to decimal representation, so programmers prefer to write byte values in hexadecimal. For example a byte whose binary value is 11010010 is D2 in hexadecimal (1101 is always D and 0010 is always 2), while in decimal we get 210.

Byte frequency/probability: it may be interesting and/or useful (e.g. for compression) to know how often different byte values appear in the data we process with computers -- indeed, this always DEPENDS; if we are working with plain ASCII text, we will never encounter values above 127, and on the other hand if we are processing photos from a polar expedition, we will likely mostly encounter byte values of 255 (as snow will cause most pixels to be completely white). In general we may expect values such as 0, 255, 1 and 2 to be most frequent, as many times these are e.g. assigned special meanings in data encodings, they may be cutoff values etc. Here is a table of measured byte frequencies in real data:

{ Measured by me. ~drummyfish }

Cache

Cache is a very small but fast computer memory that helps make communication between computer components much more efficient (typically by making it much faster or taking less bandwidth) by remembering recent requests and answers so that they don't have to be expensively repeated. The concept of cache memory is extremely important and one of the very basics for designing and optimizing hardware and software (as cache may be implemented both in hardware and software). A cache may also help prevent expensively recomputing results of functions in the same way, by remembering the recent results of the function (we may see this as a more abstract CPU-function communication). Though caches find wide use almost everywhere, without further specifying the context or type of cache the word cache most often refers to the CPU cache -- cache memory found in a CPU (nowadays in all PC CPUs, however still NOT in all embedded CPUs), which is typically further subdivided into multiple levels (L1, L2 etc.) -- here we will be using the term cache the same way, but keep in mind the principles apply everywhere and caches really are used in many places. Cache is not to be confused with a buffer (which also helps optimize communication but rather by means of creating bigger chunks to be transferred at once).

Basic principle: cache can be seen as a black box, "man in the middle" component that's placed in the line of communication between a CPU and main memory (RAM). (Physically it is nowadays part of the CPU itself, but we may imagine it as a separate component just sitting "on the wire" between CPU and RAM.) When reading from memory, we have a pretty simple situation -- once CPU requests something from the memory, the request first goes to the cache; if the cache has the result stored, it just quickly returns it -- we call this a cache hit (this is good, we saved time!). A cache miss happens when the cache doesn't have the result stored -- in such case the cache has to expensively forward the request to the memory and retrieve the data; usually the cache retrieves a whole smaller block of memory because it can be expected the CPU will access something in nearby memory in the near future (see the principle of locality below). When writing data to memory the situation is a bit more complex as the cache may choose different strategies of behavior: for simplicity it may just write the data through every time, but a more efficient (and also more complicated) approach is to just store the data for itself and write it to the main memory only when necessary (e.g. when it needs to load a different block of memory). Here we get into things such as cache coherence etc., which may cause pretty nasty bugs and headaches.

Programmers often try to optimize their programs by making them "cache friendly", i.e. they try to minimize long jumps in memory which causes a lot of cache misses and slows down the program. A typical example is e.g. storing image data in the order by which it will be written to the screen.

A cache is related and/or exploits some observations and concepts related to computers such as:

• principle of locality: Computers (/CPUs) tend to more often than not access data that are close to each other in memory, i.e. a CPU doesn't typically make random jumps in memory but rather e.g. reads a sequence of bytes one after another from an array or struct. For this reason when a CPU pulls something out of memory, there is a high probability of accessing an address that is nearby to this memory next time -- a cache helps us get ready for this by prefetching this nearby data and having it ready for very fast access.
• memory hierarchy: Mostly because of the principle of locality computer memory is divided into different levels, a chain of memories that get progressively further away from the CPU, increasing their size (decreasing price for capacity) as they get further away but also decreasing their speed. Here a cache can be seen as the closest memory to the CPU (except for the registers), i.e. being the smallest, most expensive but also fastest memory. By extension we can see that RAM can in many cases be seen as a "cache" for the hard drive, hard drive can be seen as "cache" for the network (after all web browsers ARE caching websites into files on the disk) etc.
• dynamic programming: Dynamic programming is a programming technique revolving around remembering already calculated results so that we don't have to compute them again in the future -- this is basically what caches do, they remember results we obtained in relatively expensive way so that next time we can get them cheaper.
• ...

  _____                         _____         ______         __________
 |     |        _______        |     |       |      |       |          |
 | CPU | <---> | cache | <---> | RAM | <---> | disk | <---> | Internet |
 |_____|        """""""        |_____|       |______|       |__________|
                 small           big           huge           gigantic
                 fast          slowish      super slow     extremely slow

Cache resides very close to the CPU within the memory hierarchy.

TODO: code

Cancer

Cancer is similar to shit but is even worse because it spreads itself and infects anything else it touches (it is a subset of shit).

Examples of cancer are:

• human civilization
• capitalism and many of its parts like consumerism, corporations, marketing, industrialization etc.
• pseudoleftist movements like LGBT or Feminism
• the mainstream
• fashion
• soynet, soytech
• political correctness
• nationalism, fascism, militarism, ...
• revolutions
• fight culture
• hero culture
• politics
• "personal pronouns"
• biological cancer
• ...

See Also

• shit

$$$Capitalism$$$

Capitalism is how you enslave a man with his approval.

Capitali$m is the worst socioeconomic system we've yet seen in history,^source based on pure greed, culture of slavery and artificially sustained conflict between everyone in society (so called competition), abandoning all morals and putting money and profit (so called capital) above everything else including preservation of life itself, capitalism fuels the worst in people and forces them to compete mand suffer for basic resources, even in a world where abundance of resources is already possible to achieve -- of course, capitalism is a purely rightist idea. Capitalism goes against progress (see e.g. antivirus paradox), good technology and freedom, it supports immense waste of resources, wars, abuse of people and animals, destruction of environment, decline of morals, deterioration of art, invention of bullshit (bullshit jobs, bullshit laws, ...), utilizing and perfecting methods of torture, brainwashing, censorship and so on. In a sense capitalism can be seen as slavery 2.0 or universal slavery, a more sophisticated form of slavery, one which denies the label by calling itself the polar opposite, "freedom", when in fact capitalism is merely a "freedom" to oppress others -- underlying every argument for capitalism is an argument against freedom itself; capitalism manipulates people into them approving and voluntarily partaking in their own enslavement (capitalist slaves are called wage slaves or wagies) -- this new form of slavery which enslaves everyone evolved because the old form with strictly separated classes of slaves and masters was becoming unsustainable, with the enslaved majority revolting, causing civil wars etc. This alone already seems to many like a good reason for suicide, however wage and consumption slavery is still only a small part of capitalist dystopia -- capitalism brings on destruction basically to every part of civilization. It it also often likened to a cancer of society; one that is ever expanding, destroying everything with commercialism, materialism, waste and destruction, growing uncontrollably with the sole goal of just never stop an ever accelerating growth. Nevertheless, it's been truthfully stated that "it is now easier to imagine the end of all life than any substantial change in capitalism." Another famous quote is that "capitalism is the belief that the worst of men driven by the nastiest motives will somehow work for the benefit of everyone", which describes its principle quite well.

{ Some web bashing capitalism I just found: http://digdeeper.club/articles/capitalismcancer.xhtml, read only briefly, seems to contain some nice gems capturing the rape of people. ~drummyfish }

Capitalism is fundamentally flawed and CANNOT be fixed -- capitalists build on the idea that competition will drive society, that market will be self sustaining, however capitalism itself works for instating the rule of the winners who eliminate their competition, capitalism is self destabilizing, i.e. the driving force of capitalism is completely unsustainable and leads to catastrophic results as those who get ahead in working competition are also in advantage -- as it's said: money makes money, therefore money flow from the poor to the rich and create a huge imbalance in which competition has to be highly forced, eventually completely arbitrarily and in very harmful ways (invention of bullshit jobs, creating artificial needs and hugely complex state control and laws). It's as if we set up a race in which those who get ahead start to also go faster, and those become the ones who oversee and start to create the rules of the race -- expecting a sustained balance in such a race is just insanity. Society tries to "fight" this emerging imbalance with various laws and rules of market, but this effort is like trying to fight math itself -- the system is mathematically destined to be unstable, pretending we can win over laws of nature themselves is just pure madness. Capitalism is practically equivalent to the terms free market and free trade -- today's extreme, catastrophic form of capitalism is just sufficiently evolved free market, i.e. it is impossible to support free market without supporting what we see today as long as you believe there will ever be any progress in society; against beliefs of great many unintelligent individuals, it is for example impossible to be a true anarchist as long as you believe in form of free market.

Capitalism produces the worst imaginable technology and rewards people for being cruel to each other. It points the direction of society towards a collapse and may very likely be the great filter of civilizations; in capitalism people de-facto own nothing and become wholly dependent on corporations which exploit this fact to abuse them as much as possible. This is achieved by slowly boiling the frog and leading the pig to the slaughterhouse. Capitalism further achieves enslavement of society while staying accepted by deflecting responsibility from the big picture to insignificant details: it says "Look, this politican fucked up your society! This one CEO of this corporation did it! This law here fucked your society! This one immigrant minority is responsible for it! Social media is to blame!" while in fact all of these are just symptomes of the underlying cancer of capitalism; it is relied on an average idiot's inability to see the big picture (society made mostly of idiots is achieved by indoctrination, propaganda and brainwashing that teaches one to only care about the immediate, himself and his daily food; big picture related concepts such as ethics and morality are laughed at). No one owns anything, products become services (your car won't drive without Internet connection and permission from its manufacturer), all independence and decentralization is lost in favor of a highly fragile and interdependent economy and infrastructure of services, each one controlled by the monopoly corporation. Then only a slight break in the chain is enough to bring the whole civilization down in a spectacular domino effect.

The underlying issue of capitalism is competition and conflict -- competition is the root of all evil in any social system, however capitalism is the absolute glorification of competition, amplification of this evil to maximum. It is implemented by setting and supporting a very stupid idea that everyone's primary and only goal is to be self-benefit, i.e. maximization of capital. This is combined with the fact that the environment of free market is a an evolutionary system which through natural selection extremely effectively and quickly optimizes the organisms (corporations) for achieving this given goal, i.e. generating maximum profit, on the detriment of all other values such as wellbeing of people, sustainability or morality. In other words capitalism has never promised a good society, it literally only states that everyone should try to benefit oneself as much as possible, i.e. defines the fitness function purely as the ability to seize as many resources as possible, and then selects and rewards those who best implement this function, i.e. those we would call sociopaths or "dicks", and to those is given the power in society. Yes, this is how nature works, but it must NOT be how a technologically advanced civilization with unlimited power of destruction should work. In other words we simply get what we set to achieve: find entities that are best at making profit at any cost. The inevitable decline of society can not possibly be prevented by laws, any effort of trying to stop evolution by inventing artificial rules on the go is a battle against nature itself and is extremely naive, the immense power of the evolutionary system that's constantly at work to find ways to bypass or cancel laws in the way of profit and abuse of others will prevails just as life will always find its way to survive and thrive even in the worst conditions on Earth. Trying to stop corporations with laws is like trying to stop a train by throwing sticks in its path. The problem is not that "people are dicks", it is that we choose to put in place a system that rewards the dicks, a system that fuels the worst in people and smothers the best in them.

Even though nowadays quite a lot of time has passed since times of Marx and capitalism has evolved to a stage with countless disastrous issues Marx couldn't even foresee, it is useful to mention one of the basic and earliest issues identified by Marx, which is that economically capitalism is based on stealing the surplus value, i.e. abuse of workers and consumers by owners of the means of production (factories, tools, machines etc.) -- a capitalist basically takes money for doing nothing, just for letting workers use tools he proclaims to own (a capitalist will proclaim to "own" land that he never even visited, machines he didn't make as they were developed over centuries, nowadays he even claims to own information and ideas) -- as Kropotkin put it: the working man cannot purchase with his wage the wealth he has produced. This allows a capitalist oppressor to make exponentially more money for nothing and enables existence of monstrously rich and powerful individuals in a world where millions are starving -- consider for example that nowadays there are people who own hundreds of buildings and cars plus a handful of private planes and a few private islands. It is not possible for any single human to work an equivalent of effort that's needed to produce what such an individual owns, even if he worked 24 hours a day for his whole life, he wouldn't get even close to matching the kind of effort that's needed to build the hundreds of buildings he owns -- any such great wealth is always stolen from countless workers whose salary is less than what's adequate for their work and also from consumers who pay more than it really costs to manufacture the goods they buy. Millions of people are giving their money (resources) for free to someone who just proclaims to "own" tools and even natural resources that have been there for billions of years. The difference in wealth and privileges this wealth provides divides society into antagonist classes that are constantly at war -- traditionally these classes are said to be the bourgeoisie (business owners, the upper class) and the proletariat (workers, the lower class), though under modern capitalism the division of society is not so simple anymore -- there are more classes (for example small businesses work for larger businesses) but they are still all at war.

Nowadays capitalism is NOT JUST an economic system anymore. Technically perhaps, however in reality it takes over society to such a degree that it starts to redefine very basic social and moral values to the point of taking the role of a religion, or better said a brainwashing cult in which people are since childhood taught (e.g. by constant daily exposure to private media) to worship economy, brands, performance, and to engage in cults of personalities (see myths about godlike entrepreneurs) and productivity (i.e. not usefulness, morality, efficiency or similar values, just the pure ability to produce something for its own sake). Close minded people will try to counter argue in shallow ways such as "but religion has to have some supernatural entity called God" etc. Indeed, capitalism has its own Gods (money, the successful entrepreneurs, corporations, brands, ...), fairy tales, myths and invisible entities (economy, the invisible hand, ...), rituals (entrepreneurs in expensive suits giving stage speeches like preachers, people making sacrifices for the economy, ...) and completely irrational beliefs (if you try hard enough you try hard enough you can achieve anything! listen to this tape before sleep to unlock the secret power of your brain that leads to success!). Indeed, if one tries to come up with a definition of religion that technically won't fit capitalism because he doesn't want capitalism to be a religion, he can probably do it, but it has all attributes of a religion and if we don't limit our views by arbitrary definitions of words, we see that the effects of capitalism on society are de facto of the same or even greater scale than those of a religion, and they are certainly more negative. Capitalism itself works towards suppressing traditional religions (showing it is really competing with them and therefore aspiring for the same role) and their values and trying to replace them with worship of money, success and self interest, it permeates society to the deepest levels by making every single area of society a subject of business and acting on the minds of all people in the society every single day which is an enormously strong pressure that strongly shapes mentality of people, again mostly negatively towards a war mentality (constant competition with others), egoism, materialism, fascism, pure pursuit of profit etc. Capitalism in a society ultimately leaves place for nothing but capitalism, it seizes every place for itself, just like cancer, it will eventually smother religion, ethics, art, science, technology, culture, ... whatever it is you love you will have to give up to capitalism that in the end will only be making money for the sake of being able to make money; so a capitalist can really only be that who is either too stupid to see this or just loves the purely self serving existence of money more than existence of anything else. { Reading the Trash Magic manifesto, the author also sees capitalism as a religion, confirming this view is not just my own. ~drummyfish }

From a certain point of view capitalism is not really a traditional socioeconomic system, it is the failure to establish one -- capitalism is the failure to prevent the establishment of capitalism, and it is also the punishment for this failure. It is the continuation of the jungle to the age when technology for mass production, mass surveillance etc. has sufficiently advanced -- capitalism will arise with technological progress unless we prevent it, just as cancer will grow unless we treat it in very early stages. This is what people mean when they say that capitalism simply works or that it's natural -- it's the least effort option, one that simply lets people behave like animals, except that these animals are now equipped with weapons of mass destruction, tools for implementing slavery, world wide surveillance etc. It is natural in the same way in which wars, murders, bullying and deadly diseases are. It is the most primitive system imaginable, it is uncontrolled, leads to suffering and self-destruction.

Under capitalism you are not a human being, you are a resource, at best a machine that's useful for some time but becomes obsolete and undesired once it outlives its usefulness and potential to be exploited. Under capitalism you are a slave that's forced to live the life of 3 Cs: conform, consume, compete. Or, as Encyclopedia dramatica puts it: work, buy, consume, die.

Who invented capitalism? Well, it largely developed on its own, society is just responsible for not stopping it. Capitalism as seen today has predominantly evolved from the tradition of small trade, slavery, markets, competition, evil, war and abuse due to societal hierarchy (e.g. peasants by noblemen, poor by rich etc.), combined with technological progress of industrial revolution (18th. - 19th century) which allowed mass production and mass abuse of workers, as well as the information revolution (20th - 21th century) which allowed mass surveillance, unlimited corporate control, acceleration of bullshit business and extreme mass brainwashing, reaching capitalist singularity. Adam Smith (18th century), a mentally retarded egoist with some extra chromosomes who tried to normalize and promote self-interest and torture of others for self-benefit, is often called the "father of capitalism" (which is about the same honor as being called the father of holocaust), although he didn't really invent capitalism, he merely supported its spread (saying he invented capitalism would be like saying Hitler invented killing) -- by the same spirit this man is to be also largely credited for the future extermination of all life.

{ My brother who's into movies shared with me a nice example of how capitalism ruined the art of movie dubbing (which my country has a big tradition in) -- it's just one example which however reflects many other areas that got ruined and shows why we just see this huge decline of all art and craft. Back in the day (here during a non-capitalist regime) movie dubbing was done like a play, dubbing was performed scene by scene, all actors were present, they all watched the scene together, then rehersed it several times and then dubbed it together (on a single microphone); if the result wasn't satisfactory, they tried another take until they were happy. The voice actors got time, creative freedom and were interacting together -- movie dubbing from these times are excellent works of art that sometimes even elevate the original works higher. Nowadays dubbing is done by each actor separately (no interaction between actors), each one scheduled at different time, they work without rehearsal, on first take, the translation is done on tight schedule by the cheapest translator the company finds (usually some student who's doing it as a side job at nights, soon this will probably just be done by AI), the actors are tired as hell as they have to voice many movies in a single day, they are pushed to work quickly and produce as much material as possible and to keep it safe so as to not have to risk additional takes (time loss = money loss), i.e. artistic freedom completely disappears. As different performances are recorded separately, the equipment is also more expensive (there has to be minimum noise as many records will be added together, which will amplify noise, and also someone has to do the mixing etc.). So not only are these dubbing complete and absolute soulless sterile shit without any true emotion and with laughable translation errors, they are also more expensive to make. Capitalism killed the art, humiliated it and in addition made us pay more for it. ~drummyfish }

If we continue along the lines of the valid analogy between capitalism and cancer, we notice that in the past our society used to have a kind of autoimmunity system against this cancer -- people themselves. In human body cancerous cells appear quite regularly, but the immunity system is able to kill those cells before they start growing uncontrollably, as has been happening in our society. In the past we used to have this kind of immunity too, it was the people themselves who would revolt whenever capitalist pressure became too bad -- this has amounted for a great deal of revolutions in history. The capitalism of today however already represent a malignant tumor as we're most likely beyong capitalist singularity, i.e. our society has a tumor we failed to remove at an early stage (we instead decided to feed it), it got out of hand and it can no longer be fixed now, the defensive mechanism such as revolutions are already prevented by capitalism itself, all communication between is completely controlled, thinking of people is under control too and even if people by a miracle decided to revolt, today's military is so powerful they can't even hope to stand a chance.

In capitalism only idiots survive because idots are those who capitalism can exploit and therefore those it protects (so that it can keep abusing them and making them miserable). Idiots are the conformists, those who accept lifelong slavery and misery, take loans, consume and don't cause trouble -- for that they are allowed to have kids, get healthcare, food etc. The smart do not survive in capitalism as those are not wanted.

On capitalism and Jews: rightists believe the issues caused by capitalism are really caused by Jews and that somehow getting rid of Jews will fix society -- actually this is not entirely accurate; white rightists want to remove Jews so that they (the white race) can take their place in ruling the society, so they don't actually want to fix or remove capitalism (on the contrary, they love its presence and its mechanisms), they just want to became the masters instead of slaves. It is definitely true Jews are overrepresented in high positions of a capitalist society, but that's just because Jews as a race really developped the best "skills" to succeed in capitalism as they historically bet on the right cards (focus on trade and money, decentralization of business, spread across the world and globalization, ...) and really evolved to the race best suited for the winners of the capitalist game. So while the rightist may be correct in the observation that Jews are winning the game, we of course cannot agree with their supposed "fix" -- we do not want to remove the slave masters and replace them with different ones, we want to get rid of capitalism, the unethical system itself which enables slavery in the first place.

{ There is a famous 1988 movie called They Live which, while being a funny alines'n'stuff B movie, actually deeply analyzes and criticizes capitalism and for its accurate predictions of the future we now live in became a cult classic. It's been famously said that They Live is rather a documentary. I highly recommend giving it a watch. ~drummyfish }

Attributes Of Capitalism

The following is a list of just SOME attributes of capitalism -- note that not all of them are present in initial stages but capitalism will always converge towards them.

• slavery, oppression, loss of freedom: In capitalism people are slaves firstly as workers -- in work time, so called wage slavery -- and secondly as consumers -- in "free" time. Banks create inflation to devalue money people save so that they have to work constantly for their whole lives as products are getting progressively more expensive. More and more essentially unnecessary spending purchases are forced on people -- new smartphone every year, mortgages, gas and maintenance of cars, new clothes according to fashion, insurance etc. Practically no one has a truly free time anymore.
• extreme waste: Bullshit products, bullshit jobs and the need for constant dynamics of the market force to waste energy, material and human work just to keeping everything in motion, even if purely arbitrarily. Corporations keep reinventing and reselling slightly modified version of already existing products, one group of people is creating something while another group is destroying it, just to keep everyone occupied. Byproduct physical waste such as plastics and chemicals are dumped in the environment and pollute it for decades, even centuries to come. At the moment we are already drowning in physical waste, we just export it to third world and hope they will have infinite space to store more.
• antivirus paradox: Sustaining and artificially creating undesirable phenomena so as to build a business in fighting it, to keep and create jobs ("firefighters starting fires").
  • artificial scarcity: In order to be able to sell something, that something has to be scarce, an abundant resource such as air cannot be sold. Once technology emerges to make some resource abundant, it threatens those who have a business in selling that resource. This creates the huge interest in keeping resources scarce, sometimes by force. Corporations are known to routinely destroy food that can still be eaten, and other goods as well. Corporations indirectly conspire on keeping resources scarce by artificial obsolescence, outlawing old products as "unsafe", using copyright to prevent people from recycling old intellectual works etc.
  • artificial obsolescence: To keep businesses running companies have an interest in making people consume even things that could otherwise last them even whole lives, so we see phenomena like people being forced to buy new phones every every year. There used to be the famous light bulb cartel (Phoebus cartel) that fined any bulb manufacturer that made long lasting light bulbs, bulbs were forcefully made to last for a short time. Apple has remotely decreased the performance of older iPhones when new ones came out. There are countless examples.
  • artificial crippling of technology: It is nowadays the norm to create a high tier product, such as a CPU or a car, and then artificially cripple some of the manufactured units (limit car engine power by software, burn parts of the CPU, ...) so as to sell them as a lower tier of that product. It is cheaper than to separately invent several tiers of the product. So it costs the same (actually less) to create a high end CPU as the low end one -- we could all be using high end CPUs, but the poorer of us are forced to use the forcefully crippled versions, because "capitalism".
  • purposeful incompatibility in technology: In market competition products of one company will often be incompatible with products of the competition on purpose, so as to discourage consumers from buying it. Technology corporations create their own "ecosystems" for consumers into which they are trying to lock them.
  • bullshit jobs, invention of bullshit products/needs: As automatization takes people's jobs, people try to keep jobs by creating artificial bullshit, e.g. "lack of women in tech" leads to creation of "diversity departments", politicians try to create more jobs by increasing bureaucracy etc. This is of course in direct conflict with the base goal of civilization itself of eliminating the need for human work. One online company even successfully sold literal excrement (which had no actual use, it was just marketed as "funny and cool").
  • preventing progress, sustaining status quo: Capitalism is extremely hostile towards social progress (more leisure time, more social security, ...), i.e. the main kind of progress (all progress should eventually serve well being of people, otherwise it's just artificial self-serving burden). It is also, contrary to popular belief, against technological progress -- the established corporations want to perpetuate their established businesses and will attack and destroy new ideas that endanger it (i.e. electric cars vs fuel powered cars, food corporations vs the solution of world hunger etc.). Capitalism prevents realization of any idea that's physically possible but which is economically impossible, ruling out e.g. many solutions to global heating etc. { In Trash Magic manifesto the author, a professional scientist, also shares his view that capitalism prevents innovation. ~drummyfish }
  • ...
• fascism: Capitalism is based on fascism, i.e. extreme hierarchy and "tribes" of which each fights to death for its own self interest. This fight happens between companies themselves, between state and companies, different departments inside companies, between workers and employers, between brands on the market etc. Capitalism is a constant war against everyone else -- not even jungle has this much conflict.
• no long term planning, irresponsibility: Companies need to make immediate profit, managers hired to new positions are expected to immediately increase profits and they don't come to stay for long, they have no responsibility, so they simply do whatever it takes to create immediate profit without considering any long term consequence such as pollution etc.
• extreme lowering of quality of products, deterioration of art: Despite capitalist propaganda, capitalism doesn't lead to increased quality of products -- on the contrary it seeks to find the MINIMUM quality that will be accepted by the consumer. In seeking to minimize manufacturing cost of a single unit, companies save money wherever they can and rather invest in marketing etc. -- for example instead of paying several experts to produce a good, well fact-checked documentary, only one man will be paid to create the documentary with the focus on it being "fun and engaging" rather than factually correct. Art is hasted, scheduled, produced on short deadlines, littered with product placement etc.
• plutocracy, i.e. loss of (true) democracy: In capitalism only illusion of democracy is sustained, there is no rule of the people, there is rule of the rich THROUGH people, as the rich are those who make the laws and actually take the ruling positions and who have a tremendous power to manipulate masses via private media. State is becoming more and more the tool of corporations rather than a protection against them. USA, the worst case of capitalism, is infamous for having no voting freedom, there exists just a laughable choice of two parties which are exactly the same.
• monopolies with unlimited power, degeneration of competition: The naive ideas of capitalists that markets will magically regulate themselves quickly falls apart, basically no one even tries to believe it anymore. In a competitive market monopolies arise in a short time who will prevent any competition from even arising. Can a tiny starting company compete with an established corporations with billions of dollars and thousand lawyers? No. The corporation can defeat them by gigantic marketing, unfair practices (unfair prices etc.) despite fines, by simply buying them, legal trolling, media trolling (negative internet reviews, ...), even physical attacks if necessary (just anonymously pay a bunch of hackers to DDOS competition's servers etc.). Once a monopoly without competition exists, the few advantages of competition disappear completely. A corporation doesn't respond to demand, it creates the demand. It can do whatever it likes, it can set arbitrarily high prices, create arbitrarily shitty products and so on, no competition is pressuring it to do otherwise, people have no choice than to subvert.
• poverty: Despite capitalist propaganda, not everyone can be successful in capitalism (if everyone could retire at 20, why doesn't everyone just do it?), and it is a fact that because money makes money, the gap between the poor and the rich is becoming wider and wider (as of 2020, 8 richest people owned as much wealth as the whole poorer half of the population). Poor people are pushed into loans, getting into debts, trapping themselves, working multiple jobs, while their health deteriorates increasing their debt on medical bills, decreasing their ability to work more etc.
• torture and killing of people: The poorest, mostly in third world countries, including children, are forced to hard labor that destroys their lives. Whole cities live off of processing waste coming from first world countries, e.g. disintegrating used ships with primitive tools, no work safety, breathing cancerous fumes etc.
• materialism: there exists nothing but money: By definition capitalism advises ONLY to maximize one's profit, any other values such as human well being, peace, preservation of life environment or progress are subverted to the goal of profit. As other values are often in conflict with profit, profit wins and people suffer. People are being attacked, exploited, caught in traps, hunted like animals; see e.g. usury, business with poverty and so on.
• fight culture, fascism, extreme hostility between people, disappearance of morality: The very basis of capitalism -- competition -- nurtures people towards self interest, self centeredness and hostility towards others while suppressing good attributes such as sharing, love for others and altruism. With this morals decline and fascist groups arise. Furthermore the system of overcomplicated laws are starting to replace morals, people ask "is it legal?" rather than "is it a good thing to do?". This creates a society of dicks and psychopaths who are additionally rewarded for their immoral behavior by becoming "successful" and wealthy. In long term this serves as a natural selection in Darwinian evolution, immorally behaving people are actually more likely to survive and reproduce, which leads to genes of psychopathic behavior becoming more and more common in society -- under capitalism good people quite literally become extinct in the long run.
• fear culture: To keep people consuming and constantly engaged a tension has to be kept, comfortable people are undesirable in capitalism. So there is constantly a propaganda of some threat, be it viruses, terrorism, pedophiles on the internet, computer viruses, killing bees etc.
• consumerism: To keep businesses running people need to consume everything, even things that shouldn't be consumed and that could last for very long such as computers and cars. This leads to creation of hasted low quality products (even art such as TV series) that are meant to be used and thrown away, repairing is no longer considered.
• commerce infects absolutely everything: In advanced capitalism there is no such thing as a commerce free zone, everything is privatized eventually and serves selfish interests. There is nowhere to hide, capitalism has to work towards eliminating escape places as abused people will want to naturally retreat from a place of abuse somewhere safe. Nowadays even such areas as health care, welfare or education of children is permeated by money, ads and corporate propaganda. Even nonprofits have to make money. Educational videos in schools are preceded with ads (as they are played on YouTube), propagandists even legally go to school and brainwash little children (they call it "education in financial literacy" and teach children that they should e.g. create bank accounts in the propagandist's specific bank).
• destruction of life environment: This is nowadays already pretty clear, global heating is attributed mainly to capitalism and is seen as maybe the most likely doom that's probably already unavoidable. Lack of long term planning and any concern for anything but money, along with consumerism and extreme waste (of energy, physical waste such as plastic, toxic chemicals etc.) lead to building bullshit factories and performing unnecessary activity for economic reasons (e.g. transporting materials over the globe for assembly, then transporting it back), leading to extreme pollution of air (visible air smog already makes it hard to breathe in many cities), water (it is no longer safe to drink rain water as it used to be) and food (microplastic particles are already basically EVERYWHERE, eating them can't be avoided). Forests that are necessary for cleaning air, host many precious life forms and are overall a key part of ecosystem are being destroyed rapidly, entire species are disappearing very quickly. And that's just a quick sum up.
• rule of idiots: Under capitalism the incompetent become successful as success isn't a matter of competence at art but rather willingness to win for any cost, matter of persevering despite being untalented, succumbing to unethical behavior, investing into "promoting" oneself through marketing, social media etc. The truly skilled and intelligent often see the system is bullshit, the skilled are skilled before they want to do their art rather than engage in fights, so they get depressed and disgusted and leave to live in the underground, they live only for their art, opening the way for the unskilled, stupid and at best average thirsty for success. That's why there are so many "professional" wedding photographers who know absolutely nothing about photography, so many elementary school drop outs who become celebrities on TikTok and YouTube who go on to advise the masses on who to vote for in the elections, so many shitty movies, music and games, so many "programmers" and "security experts" who can't do elementary school math etc.
• loss of ethical and moral behavior: Ethical behavior is a disadvantage in a competitive environment of the market, it is a limitation. Those trying to behave ethically (e.g. fair prices or good treatment of employees) will simply lose to the unethically behaving ones and be eliminated from the market. Eventually there only remain unethically behaving entities, which is exactly what we are seeing nowadays -- there basically doesn't exist a single ethically behaving corporation in the world (which has however already been normalized and is no longer seen as an issue). { Where I live there is an old proverb that says "self praise stinks", it's an old wisdom that correctly states people who aren't humble are always evil idiots. Capitalism stands on massive marketing and basically goes all in on this evil, marketing school are nothing but teaching self praise. ~drummyfish }
• anti-people design: By definition in capitalism technology is not to serve people, it is to serve companies to make profit and abuse people, so technology spies on its users, refuses to work (DRM, ...) shows ads, forces children into purchases (predatory games), breaks on purpose so as to enforce a paid repair etc.
• censorship: One kind of capitalist censorship is so called intellectual property (allowing "ownership" of ideas, art etc.), but there are many more, e.g. so called moderation of social media which censors specific political views (deemed "politically incorrect" and hence "dangerous" for the advertising potential or brand of the platform) or sharing of certain facts (e.g. those revealing unethical practice of the platform itself, negative reviews of its products etc.). Privately owned media lawfully censor and manipulate information so as to manipulate people in whichever way they see will bring them most profit. While "intellectual property" is marketed as "protecting intellectual workers", in practice it serves corporations and states to do whatever they want, from political censorship, deception and implementing surveillance (justified by "antipiracy") to legal bullying and implementing artificial scarcity ("no, you can't grow this type of food on your field as the plant is patented; only we can grow it and you have to buy it from us in order to live").
• surveillance: Companies want to analyze behavior of people, manipulate them, target ads, spam, train neural networks on their data etc., so there is a huge interest in applying surveillance. Indeed, this is exactly what we see in practice -- this is not even a conspiracy theory, cases of revealed mass surveillance are almost daily news.
• extreme brainwashing and propaganda: Marketing reaches extreme levels in capitalism, utilizing advanced psychological tricks and repetition to the point of becoming a torture, with the goal of teaching people brand loyalty, consumerist behavior etc. Application of this brainwashing even on children has already been normalized. Entrepreneurs create cults of personalities. There is now even a "legit" job called an influencer whose sole purpose is in spreading corporate propaganda on the Internet.
• criminality: This is a direct consequence of poverty, awful working conditions, fight culture and overall diminishing morality. Poor people (the absolute majority in the system) become desperate and do desperate things -- of course, all blame is put on them, not on those who are responsible for their poverty.
• instability: Lack of long term planning, extreme interdependence, monopolies over essential resources, fragility of the market, increasing wealth gap, pushing workers to poverty while taking away social security, eliminating self sufficiency, extreme waste and other phenomena pose great dangers of market collapses, violent strikes and revolutions, running out of resources, destruction of living environment and other disasters and even societal collapse.
• need for extremely complex market control and laws, burdening society: As corporations are absolutely unethical and pursue evil goals such as enslaving workers and abuse of consumers, there have to be an extremely complex set of constantly evolving laws and bureaucracy just to somehow "make corporations behave". However laws are imperfect and corporations work 24/7 on bypassing them as well as on attacking and eliminating the laws themselves via lobbyist etc. This creates a constant, extremely expensive legal war-like game in which everyone has to take part, which is completely arbitrary and unnecessary and which eventually corporations will likely win.
• uncontrolled growth: Capitalism is likened to cancer as it requires a constant uncontrolled growth which on a planet of limited resources inevitably leads to a catastrophic scenario.
• hyperspecialization, loss of self sufficiency: Entities (people, cities, companies, states, ...) lose self sufficiency as they hyperspecialize in some task and in everything else rely on someone else. This complete dependence creates slavery and danger -- in an event of a blackout for example people cannot survive as they cannot make their own food, they can't repair their basic tools etc.
• 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 concerning to 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: 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", ...) 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". 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: The mechanisms of capitalism work in such ways that everyone gets progressively more raped with any further advance of capitalism.
• endangering existence of all life: The mentioned destruction of environment, lack of long term planning, irresponsibility and instability along with creating a dangerous overdependence on technology and interconnections of self insufficient states and cities is just waiting for a disaster such as CME that immediately collapses the civilization and consequently endangers all life on Earth e.g. by meltdowns in nuclear plants or possible nuclear wars as a consequence of panic. The absolute preference of immediate profit is hostile towards investments in future and precautions. RIP.
• ...

How It Works

The "old" capitalism, or perhaps its basic forms, that socialist writers have analyzed very well is characterized mainly by abuse of workers by capitalists who declare to "own" means of production such as factories, land and machines -- as e.g. Kropotkin has written in The Conquest of Bread, it is poverty that drives capitalism because only a poor man who just needs ANY salary for himself and his family will accept horrible working conditions and low pay, simply because he has no other choice -- a capitalist exploits this, "employs" (enslaves) the poor and then only pays them as much as to keep the barely alive and working for him, and he further has the audacity of calling himself an "altruist" who "feeds" people and "gives them a work"; a capitalist employs workers in his factory like he employs chicken in egg factories or pigs in slaughterhouses -- in modern days many may fall to the illusion that workers aren't poor anymore as they may posses smartphones and big screen TVs, but in essence a worker still lives salary to salary and is in desperate need of it; without a salary he will quickly end up starving in the street. Workers do labor that's in itself worth a lot but the capitalist only gives him a small salary, firstly to gain own profit and secondly to keep the worker poor because again, only a poor man will work for him. This is also why capitalists are against anything that would end poverty, such as universal basic income. If the workers owned the factory collectively and didn't have to cut the profit off their labor, they wouldn't have to work so many hours in such harsh conditions at all, it's only because there is a capitalist leech at the top that everyone has to slave himself to death so that the leech can get enormously rich.

Here a capitalist says to the worker: "I am not forcing you to slavery, if you don't like the working conditions, go elsewhere". Of course, this is a laughable insult -- the capitalist knows very well there is nowhere else to go; wherever you go work in capitalism, you get exploited -- you can only do as much as choose your slavemaster. A capitalist will then say: "start your own business then", which again is a complete idiocy -- it's extremely hard to succeed in business, not everyone can do it, those who have established businesses won't let anyone on the market, and of course it's the immoral thing to do, the capitalist is just telling you to start doing what he's doing: abuse others. If you do start your business, he will be sure to attack you as a competition and with his power he will very likely be able to stop your business. So this advice is similar to that of "go start your own country if you don't like this one" -- he might as well tell you to move to another planet.

The new, modern capitalism is yet worse as it takes full advantage of technology never before seen in history which allows extreme increase of exploitation of both workers and consumers -- now there are cameras and computers watching each worker's individual production, there are "smart" devices spying on people and then forcing ads on them, there are loud speakers and screens everywhere full of propaganda and brainwashing, nowhere to escape. Now a single capitalist can watch over his factories all over the world through Internet, allowing for such people to get yet much richer than we could ever imagine.

While the old capitalism was more of a steady slavery and the deterioration of society (life environment, morality, art, ...) by it was relatively slow (i.e. it seemed to be somewhat "working"), nowadays, in the new capitalism the downfall of society accelerates immensely. In countries where capitalism is newly instated, e.g. after the fall of an old regime, it indeed seem to be "working" for a short time, however it will never last -- initially when more or less everyone is at the same start line, when there are no highly evolved corporations with their advanced methods of oppression, small businesses grow and take their small shares of the market, there appears true innovation, businesses compete by true quality of products, people are relatively free and it all feels natural because it is, it's the system of the jungle, i.e. as has been said, capitalism is the failure to establish a controlled socioeconomic system rather than a presence of a purposefully designed one. Its benefits for the people are at this point only a side effect, people see it as good and continue to support it. However the system has other goals of its own, and that is the development and constant growth that's meant to create a higher organism just like smaller living cells formed us, multi cell organisms. The system will start being less and less beneficial to the people who will only become cells in a higher organism to which they'll become slaves. A cell isn't supposed to be happy, it is supposed to sacrifice its life for the good of the higher organism.

{ This initial prosperous stage appeared e.g. in Czechoslovakia, where I lived, in the 90s, after the fall of the totalitarian regime. Everything was beautiful, sadly it didn't last longer than about 10 years. ~drummyfish }

Slowly "startups" evolve to medium sized businesses and a few will become the big corporations. These are the first higher entities that have an intelligence of their own, they are composed of humans and technology who together work solely for the corporation's further growth and profit. A corporation has a super human intelligence (combined intelligence of its workers) but has no human emotion or conscience (which is suppressed by the corporation's structure), it is basically the rogue AI we see in sci-fi horror movies. Corporation selects only the worst of humans for the management positions and has further mechanisms to eliminate any effects of human conscience and tendency for ethical behavior; for example it works on the principle of "I'm just doing my job": everyone is just doing a small part of what the whole company is doing so that no one feels responsible for the whole or sometimes doesn't even know what he's part of. If anyone protests, he's replaced with a new hire. Of course, many know they're doing something bad but they have no choice if they want to feed their families, and everyone is doing it.

Deterioration of society is fast now but people are kept in a false sense of a feeling that "it's just a temporary thing", "it's this individual's fault (not the system's)" and that "it's slowly getting better", mainly with the help of 24/7 almighty media brainwashing. Due to heavy greenwashing, openwashing etc. most people are for example naively convinced that corporations are becoming more "environment friendly", "responsible", "open source" ("Microsoft isn't what it used to be", ...) etc., as if a corporation had something akin emotion instead of pure desire for profit which is its only goal by definition. A corporation will repeat ads telling you it is paying black handicapped gays to plant trees but internally no one gives a shit about anything but making more money, a manager's job is just to increase profit, waste is increasing and dumped to oceans when no one is looking, bullshit is being invented to kickstart more bullshit business which leads to more need for energy wasting (unnecessary transportation, upkeep of factories and workplaces, invention of bullshit technology to solve artificial problems arising from artificial bullshit). A lie repeated 1000 times a day will beat even truth that's evident to naked eye, basic logic and common sense. Even when sky is littered with ads, cities are burning and people are working 20 hours a day, a capitalist will keep saying "this is a good society", "we are just in a temporary crisis", "it is getting better" and "I care about the people", and people will take it as truth.

Corporations make calculated decisions to eliminate any competition, they devour or kill smaller businesses with unfair practices (see e.g. the Microsoft's infamous EEE), more marketing and by other means, both legal and illegal. They develop advanced psychological methods and extort extreme pressure such as brainwashing by ads to the population to create an immensely powerful propaganda that bends any natural human thinking. With this corporations no longer need to satisfy the demand, they create the demand arbitrarily. They create artificial scarcity, manipulate the market, manipulate the people, manipulate laws (those who make laws are nowadays mostly businessmen who want to strengthen corporations whose shares they hold and if you believe voters can somehow prevent such psychopaths getting this power, just take a look literally at any parliament of any country). At this point they've broken the system, competition no longer works as idealized by theoretical capitalists, corporations can now do practically anything they want.

This is an evolutionary system in which the fitness function is simply the ability to make capital. Entities involved in the market are simply chosen by natural selection to be the ones that best make profit, i.e. who are best at circumventing laws, brainwashing, hiding illegal activities etc. Ethical behavior is a disadvantage that leads to elimination; if a business decides to behave ethically, it is outrun by the one who doesn't have this weakness.

The unfair, unethical behavior of corporations is still supposed to be controlled by the state, however corporations become stronger and bigger than states, they can manipulate laws by lobbying, financially supporting preferred candidates, favoring them with their propaganda etc. States are the only force left supposed to protect people from this pure evil, but they are too weak; a single organization of relatively few people who are, quite importantly, often corporation share holder, won't compete against a plethora of the best warriors selected by the extremely efficient system of free market. Furthermore voters, those who are supposed to choose their protectors, are just braindead zombies now who literally do what their cellphones shows them on its display. By all this states slowly turn to serving corporations, becoming their tools and then slowly dissolve (see how small role the US government already plays). Capitalist brainwashing is so strong that it even makes people desire more torture -- see so called "anarcho" capitalism which the stupidest of our population have already fallen for and which is basically about saying "let's get rid of anything that protects us against absolute capitalist apocalypse". "Anarcho" capitalism is the worst stage of capitalism where there is no state, no entity supposed to protect the people, there is only one rule and that is the unlimited rule of the strongest corporation which has at its hands the most advanced technology there ever was.

Here the strongest corporation takes over the world and starts becoming the higher organism of the whole Earth, capitalist singularity has been reached. The world corporation doesn't have to pretend anything at this point, it can simply hire an army, it can use physical force, chemical weapons, torture, unlimited surveillance, anything to achieve further seize of remaining bits of power and resources.

People will NOT protest or revolt at this point, they will accept anything that comes and even if they suffer everyday agony and the system is clearly obviously set up for their maximum exploitation, they will do nothing -- in fact they will continue to support the system and make it stronger and they will see more slavery as more freedom; this tendency is already present in rightists today. You may ask why, you think that at some point people will have enough and will seize back their power. This won't happen, just as the billions of chicken and pigs daily exploited at factories won't ever revolt -- firstly because the system will have absolute control over people at this point, they will be 100% dependent on the system even if they hate it, they will have proprietary technology as part of their bodies (which they willingly admitted to in the past as part of bigger comfort while ignoring our warnings about loss of freedom), they will be dependent on drugs of the system (called "vaccines" or "medicine"), air that has to be cleaned and is unbreathable anywhere one would want to escape, 100% of communication will be monitored to prevent any spark of revolution etc. Secondly the system will have rewritten history so that people won't see that life used to be better and bearable -- just as today we think we live in the best times of history due to the interpretation of history that was force fed us at schools and by other propaganda, in the future a human in every day agony will think history was even worse, that there is no other option than for him to suffer every day and it's a privilege he can even live that way.

We can only guess what will happen here, a collapse due to instability or total destruction of environment is possible, which would at least save the civilization from the horrendous fate of being eternally tortured. If the system survives, humans will be probably be more and more genetically engineered to be more submissive, further killing any hope of a possible change, surveillance chips will be implanted to everyone, reproduction will be controlled precisely and finally perhaps the system will be able, thanks to an advanced AI, to exist and work more efficiently without humans completely, so they will be eliminated. This is how the mankind ends.

{ So here you have it -- it's all here for anyone to read, explained and predicted correctly and in a completely logical way, we even offer a way to prevent this and fix the system, but no one will do it because this will be buried and censored by search engines and the 0.0000000000001% who will find this by chance will dismiss it due to the amount of brainwashing that's already present today. It's pretty sad and depressive, but what more can we do? ~drummyfish }

Capitalist Propaganda And Fairy Tales

Capitalist brainwashing is pretty sophisticated -- unlike with centralized oppressive regimes, capitalism has a decentralized way of creating and spreading propaganda, in ways similar to for example self-replicating and self-modifying malware in the world of software. Creators and promoters of capitalist propaganda are mostly people who are unaware of doing so, they have been brainwashed and programmed by the system itself to behave that way, for example just by being exposed to hearing the capitalist fairy tales since they were born. Some examples of common capitalist propaganda you will probably encounter are the following:

• "Capitalism is freedom." -- This is of course a complete twist of the word freedom: capitalism promotes freedom of market which goes against the freedom of people. I.e. the freedom enabled by capitalism is the freedom to abuse others; the freedom to restrict freedoms of others, which is of almost the polar opposite of genuine freedom.
• "In capitalism everyone can make it if he only works hard." -- This is firstly of course not even logically possible, it's just as claiming that everyone can win the Olympic games; to reach the top in an extremely competitive system not only do you have to work hard, you also have to be born with the right talent, in the right place, to the right family, and be immensely lucky to be in right places in right times and make correct guess decisions in situations in which it is impossible to know the correct decision. Even if you work 24/7 without sleep, there will be thousands of others who do the same, your success is a pure bet on lottery. Capitalist fairy tales make heavy use of the survivorship bias -- you will see movies only about the successful people who are asked how they achieved success and who answer along the lines "I just worked hard". Indeed they did, but this doesn't imply that anyone working hard will succeed, this is the same as taking an advice from a lottery winner; if you ask a lottery winner how he won the lottery, he will simply say "I bet all I had on a random number". Following such advice is of course just about the worse decision you can make. If everyone can make it, why doesn't everyone do it, why don't we have a world consisting exclusively of billionaires?
• "Capitalism just works, capitalism is natural, capitalism means progress etc." -- Capitalism doesn't work, it's just hard to get rid of. Progress isn't dependent on capitalism, progress can't be stopped and will be here even without capitalism. If it "works and is natural", then it works and is natural natural in the same way as for example cancer or wars. This doesn't mean we should support it or see it as something positive. Most of other similar lies are discussed in sections above.
• Fairy tales about about the rich capitalist altruist: you will hear stories about famous capitalists that paint them as nice guys who give to poor for free, who do manual work despite not having to etc. This is just part of cult of personality propaganda and applying cheap populist tricks to deceive masses. A rich guy giving $100 to a poor kid on camera is an extreme powerful marketing that costs $100, which for a billionaire is of course a laughable cost. The fact is that every billionaire is the best player of the most dirty game humanity has invented and researching any such guy reveals, basically in 100% of cases, that he was in fact the worst imaginable psychopath -- Edison killed animals with electric current as part of marketing, the owner of McDonald's stole the idea and know-how from McDonald brothers ALONG WITH their own name, similar thing happened with KFC, Steve Jobs was infamous for his psychological pressure on workers equating torture, the working condition's in Ford's factories were basically the same as those for black African slaves, etcetc. Trying to find a rich man that's good is like trying to find a shark who's a vegetarian.
• "Capitalism isn't perfect but it's the best system we know.": complete bullshit, capitalism is probably the worst system that there ever was. See this whole article.
• "Successful capitalists are the most intelligent people.": on the contrary, mostly the stupidest people become successful -- success in capitalism depends mostly on luck and lack of moral obstacles, i.e. doing whatever it takes to succeed such as stabbing friends in the back, public lying, exploitation of workers etc. High intelligence is actually a disadvantage in this manner as it makes one see all the negative consequences of his behavior, a smart man sees that by engaging in capitalism he is not just hurting and even killing other people, but even e.g. working towards destruction of art, culture, living environment and possibly life itself. Being a successful businessman in capitalism is like steering a plane full of people, including oneself, towards ground -- only an idiot can do it.
• TODO: moar

So What To Replace Capitalism With?

At this point basically anything else is better. But we here advocate less retarded society.

See Also

• dystopia
• fascism
• "anarcho" capitalism
• 1984
• corporation

Capitalist Singularity

Capitalist singularity is a point in time at which capitalism becomes irreversible and the cancerous growth of society unstoppable due to corporations taking absolute control over society. It is when people lose any power to revolt against corporations as corporations become stronger than states and any other collective effort towards their control.

This is similar to the famous technological singularity, the difference being that society isn't conquered by a digital AI but rather a superintelligent entity in a form of corporation. While many people see the danger of superintelligent AIs, surprisingly not many have noticed that we've already seen rise of such AIs -- corporations. A corporation is an entity much more intelligent than any single individual, with the single preprogrammed goal of profit. A corporation doesn't have any sense of morals as morals are an obstacle towards making profit. A corporation runs on humans but humans don't control them; there are mechanisms in place to discourage moral behavior of people inside corporations and anyone exhibiting such behavior is simply replaced.

Capitalist Software

Capitalist software is software that late stage capitalism produces and is practically 100% shitty modern bloat and malware hostile to its users, made with the sole goal of benefiting its creator (often a corporation). Capitalist software is not just proprietary corporate software, but a lot of times "open source", indie software and even free software that's just infected by the toxic capitalist environment -- this infection may come deep even into the basic design principles, even such things as UI design, priorities and development practices and subtle software behavior which have simply all been shaped by the capitalist pressure on abusing the user.

{ Seriously I don't have enough brain to understand how anyone can accept this shit. ~drummyfish }

Capitalist software largely mimics in technology what capitalist economy is doing in society -- for example it employs huge waste of resources (computing resources such as RAM and CPU cycles as an equivalent to natural resources) in favor of rapid growth (accumulation of "features"), it creates hugely complex, interdependent and fragile ever growing networks (tons of library of hardware dependencies as an equivalent of import/export dependencies of countries) and employs consumerism (e.g. in form of mandatory frequent updates). These effects of course bring all the negative implications along and lead to highly inefficient, fragile, bloated, unethical software.

Basically everyone will agree that corporate software such as Windows is to a high degree abusive to its users, be it by its spying, unjustified hardware demands, forced non customizability, price etc. A mistake a lot of people make is to think that sticking a free license to similar software will simply make it magically friendly to the user and that therefore most FOSS programs are ethical and respect its users. This is sadly not the case, a license if only the first necessary step towards freedom, but not a sufficient one -- other important steps have to follow.

A ridiculous example of capitalist software is the most consumerist type: games. AAA games are pure evil that no longer even try to be good, they just try to be addictive like drugs. Games on release aren't even supposed to work correctly, tons of bugs are the standard, something that's expected by default, customers aren't even meant to receive a finished product for their money. They aren't even meant to own the product or have any control over it (lend it to someone, install it on another computer, play it offline or play it when it gets retired). These games spy on people (via so called anti-cheat systems), are shamelessly meant to be consumed and thrown away, purposefully incompatible ("exclusives"), bloated, discriminative against low-end computers and even targeting attacks on children ("lootboxes"). Game corporations attack and take down fan modification and remakes and show all imaginable kinds of unethical behavior such as trying to steal rights for maps/mods created with the game's editor (Warcraft: Reforged).

But how can possibly a FOSS program be abusive? Let's mention a few examples:

• Being a bloat monopoly.
• Allowing maintenance cost to be high and prioritizing e.g. features over maintainability leads to programs being expensive to maintain which discriminizes against developers unable to pay this maintenance cost. If a rich corporation intentionally makes their program bloated and expensive to just maintain, it ensures no one poor will be able to fork the software and maintain it (let alone shape it into something better), which effectively removes the possibility of an ethical competition being made out of their "open source" program.
• Bloat, intentional obscurity and update culture may lead to de-facto (as opposed to de-jure) limitations of basic freedom conditions, despite a free license. Specifically freedom 1 (to study the software, which may be unnecessarily difficult and expensive) and 2 (to modify the software, which requires its understanding, unnecessarily high cost of dealing with bad code and the ability to compile it which may be non-trivial). Therefore a company may, on paper, provide the rights to study and modify their program, but keep the actual know-how of the program's working and modification private, de-facto becoming the program's owner and sole controlling entity.
• Allowing proprietary dependencies, which happens especially in open source. While free software usually avoids this, open source is happy with e.g. Windows-only programs which of course requires the users to run abusive code in order for the program to function.
• Unnecessarily high hardware demands and dropping support for old hardware which drives consumerism and discriminates against poor people and people who just don't want to "consoom" hardware. A group can make "open source" software that intentionally requires the latest hardware that they just happen to sell (e.g. gaymes with "AAA graphics"), even if the software might in theory run on older hardware. Possible "fixes" of this by third parties can be prevented by the above mentioned techniques.
• Allowing bloat to increase the risk of security vulnerabilities and bugs (which may in some ares be fatal and lead to literal deaths).
• Obscurity and interdependence may be used to successfully hide malicious features even within publicly accessible code. See for example the anti-Russian "protestware" cases such as node-ipc, an "open source" package that introduced malicious file-wiping code and infected all software depending on it.
• Introducing dangerous dependencies: for example a fully free software may be unnecessarily designed as cloud software which increases the risk of its non functionality e.g. in cases of Internet blackouts (or just any loss of connection).
• Licenses can by bypassed, e.g. copyleft was legally eliminated by Google's Android which is based on copylefted Linux: their proprietary Play Store is a 3rd party program to which the copyleft doesn't apply but which is essential for Android and serves to control Android (which should have been prevented by the copyleft). This is an example of a FOSS "protection mechanism" failing under capitalist pressure.
• Setting up discriminatory, fascist and toxic centralized development communities that de-facto own and control the software and use discriminatory practices and censorship, e.g. with codes of conduct. This allows to bully and "cancel" developers who are, for political or any other reason, unwelcome.
• Even free software may behave in unethical ways. For example a company that profits from gambling may create a completely "FOSS" game for children that however teaches them gambling so that when they grow up they'll be more likely to become their victims.

The essential issue of capitalist software is in its goal: profit. This doesn't have to mean making money directly, profit can also mean e.g. gaining popularity and political power. This goal goes before and eventually against goals such as helping and respecting the users. A free license is a mere obstacle on the way towards this goal, an obstacle that may for a while slow down corporation from abusing the users, but which will eventually be overcome just by the sheer power of the market environment which works on the principles of Darwinian evolution: those who make most profit, by any way, survive and thrive.

Therefore "fixing" capitalist software is only possible via redefinition of the basic goal to just developing selfless software that's good for the people (as opposed to making software for profit). This approach requires eliminating or just greatly limiting capitalism itself, at least from the area of technology. We need to find other ways than profit to motivate development of software and yes, other ways do exist (morality, social status, fun etc.).

Cat-v

Cat-v.org (accessible at http://cat-v.org) is a minimalist hacker website describing itself as a random contrarian insurgent organization which promotes critical thinking, free speech, examines technology from minimalist point of view, opposes orthodoxy and talks about wider context of technology such as politics, society and philosophy; the site hosts a few "subsites", e.g. those related to Plan 9 OS and Go language, however most famous is its encyclopedia of things considered harmful (http://harmful.cat-v.org/). The whole site, especially the "harmful" section (which was the first one), revolves around the phrase "considered harmful" -- this is basically a computer science academic meme that started with a 1968 paper named "Go To Statement Considered Harmful" which was later followed by dozens of similarly named articles; cat-v is taking this to the next level by building a whole website about all things considered harmful. The name of the site itself comes from Rob Pike's 1983 presentation "UNIX Style, or cat -v Considered Harmful" that criticized the -v flag of the Unix cat program as such flag, strictly speaking, violates the Unix philosophy (cat should only concatenate files, the flag makes it do something that should rather be done by another program). Though maybe coincidental, the name is also similar to CatB (a short for famous hacker essay/book Cathedral and Bazaar). The site is very nice, made in plain HTML minimalist style, working with HTTP and besides others contains a ton of great quotes on every topic, there is also an IRC, mailing list and a blog.

The section "considered harmful" contains many things, even quite general ones, probably to provoke thought -- one should likely not see a thing present on the list as something we have to always necessarily get rid of -- though many times we should! -- sometimes we just may think about how to improve the thing or minimize its negative impact; try to think of harmful things like "things that suck"; everything sucks, some things just suck less. Among things listed under the harmful section are besides others all software, OOP, GNU, Linux, C++, dynamic linking, Java, XML, vim, Emacs, GPL (one recommended alternative being CC0 instead), Perl, standards, Sweden, gay marriage, marriage, children, words, intellectual property, religion, science, minimum wage, the Avatar movie, Wikileaks, people, economics, global warming scaremongering, security theater etc.

Cat-v has existed since at least 2005 (according to Internet Archive) and was started by Uriel M. Pereira, a minimalist hacker who greatly contributed to a lot of suckless software and who committed suicide in 2012. Suckless and cat-v seem to be pretty close -- suckless.org has its own section of harmful things called simply "sucks".

From LRS point of view cat-v is based in great many ways, mainly its focus on the big picture and wider context or technology, promotion of minimalism, freedom of speech and thinking and anti-orthodoxy -- it is not a soyboy site, good quality sites without SJWery are greatly appreciated. However we would also find disagreements e.g. on Plan 9 and Go, which we consider greatly harmful. And of course some politics etc.

See Also

• suckless

CC0

CC0 is a waiver (similar to a license) of copyright, created by Creative Commons, that can be used to dedicate one's work to the public domain (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 and permissive option for releasing intellectual works. CC0 is designed in a pretty sophisticated way, it also waives "neighboring rights" (e.g. moral rights; waving these rights is why we prefer CC0 over other waivers such as unlicense), 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 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 for both programs and other art -- however for programs additional waivers of patents should be added as CC0 doesn't deal with patents. CC0 is endorsed by the FSF but not OSI (who rejected it because it explicitly states that trademarks and patents are NOT waived).

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.

Some things under CC0 include Librivox audiobooks, Dusk OS, Wikidata database, great many things on sites like Wikimedia Commons, opengameart (see e.g. Kenney), Blendswap, freesound etc., whole Esolang Wiki, OSdev Wiki (since 2011), Encyclopedia Dramatica, LRS software (Anarch, small3dlib, raycastlib, SAF, comun) and LRS wiki, books like The Pig and the Box (anti DRM child story) or Cost of Freedom, some fonts by dotcolon, Lix (libre game), evlisp minimalist Lisp (from book "Lisp From Nothing") and many others.

CC

CC can stand for:

• Creative Commons
• C compiler
• ...