by drummyfish, generated on 07/19/26, available under CC0 1.0 (public domain)
This is a censored and old version of the LRS wiki.
3d_modelIn the world of computers and programming (above all 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. It is model in mathematical sense, i.e. an approximation or idealization of a shape that usually exists in real world but in its infinite complexity couldn't be represented in the computer. One of the first things we'll want to do with a 3D model is to draw it on the screen -- we call this 3D rendering, and this may be achieved through various rendering techniques and algorithms, but 3D models serve many more purposes than graphics: for example they're a vital part of simulations of the real world physics (e.g. games, architectural calculations, car crash simulations, ...), because real world is, as we know, three dimensional. 3D models can be created in various ways too, e.g. manually with 3D modeling software (such as Blender) by 3D artists, by 3D scanning real world objects, automatically using procedural generation, artificial intelligence etc. It is even possible to create 3D models without a computer, just with pen and paper.
As of 2025 3D models are dead, killed by capitalism. There are no significant 3D models to speak of now.
In the world of computer graphics there exist various famous 3D models often used as "de facto standard" test subjects of new algorithm and/or for presentation thereof. These include for example the Utah Teapot (Bezier patch model, from 1976) and Stanford Bunny (scanned model, 69451 tris, 35947 verts).
There is a plethora of different 3D model types, the topic is very wide spanning and volume of literature is enormous when examining it in the scope of all possible areas that 3D models are used in because 3D models can really be used and represented in many ways, each of which is a tradeoff of various attributes that have different weights in different areas and industries. Everything is yet more complex by dealing with different methods of 3D rendering that favor different representations of 3D models -- the universal, 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, hybrid etc. Models may also bear additional extra information and features, e.g. material, mass, bone rigs for animation, animation key frames, density information, collision shapes, 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 probably (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 let's say STL, seen 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 a 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):
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.
Animation: the main approaches to animation are these (again, just the important ones, you may encounter other ways too):
Texturing must be briefly mentioned as well as an important part of traditional 3D modeling. In the common, narrower sense texture is a plain 2D image which is stretched onto the model's surface in order to conjure more detail, just like we glue a wallpaper onto a wall -- without textures our models show only flat looking surfaces, only with a constant color (at best we may assign each polygon a different color, but that won't make for a very realistic model). The application of texture on the model is called texture mapping -- you may also come across 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 }
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.
WORK IN PROGRESS
Are you dreaming about 3D modeling? Or do you perhaps already know a bit about it and just want some advice to get better by any chance? Then let this section serve us to share a few words of advice for doing just that.
Let us preface by examining the hacker chad way of making 3D models, i.e. the LRS way 3D models would 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 near 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 automate 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:
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).
So finally let's recount some of the advice:
And should you appreciate a challenge or inspiration, let us leave with a list of models you can make for practice, ordered roughly from the simplest to most difficult:
Good luck with your modeling!
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.
To this end we now have many methods and algorithms 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.
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 graphics programmer quickly comes to realize that 3D rendering is to a great extent about faking (especially the mainstream realtime 3D) -- it is an endeavor seeking creation of something that looks familiar and satisfyingly good specifically to HUMAN sight and so even though the methods are mathematical, the endeavor really equates art in the end, not dissimilar to that of a magician inventing "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 visual perception such as "60 FPS looks like smooth movement", "infrared spectrum is invisible", "humans can't tell a mirror reflection is slightly off", "inner corners of objects 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 SUBJECTIVE judgment of a human (and sometimes every individual). In theory -- if we had infinitely powerful computers -- we might just program in a few lines of electromagnetic equations and run the precise simulation of light propagating in 3D environment to obtain absolutely realistic results, but though some methods try to come close to said approach, we simply can't ever hope to invent an infinitely powerful computer. 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).
Having said this, let's now take a look at possible classifications of 3D rendering methods. As seen, there are many ways:
Finally a table of some common 3D rendering methods follows, including the most primitive, most sophisticated and some unconventional ones. Note that here we highlight methods and techniques rather than algorithms, i.e. general approaches that are frequently modified and combined into a concrete rendering algorithm. As an example the traditional triangle rasterization has recently started to be combined with raytracing to add realistic reflections etc. The methods may also be additionally enriched with features such as texturing, antialiasing and so on. The table below should help finding the base 3D rendering method to further shape to any program's specific needs.
The methods may be tagged with the following:
| method | notes |
|---|---|
| 3D raycasting | IO off, shoots rays from camera |
| 2D raycasting | IO 2.5D, e.g. Wolf3D |
| AI image synthesis | "just let AI magic do it" |
| beamtracing | IO off |
| billboarding | OO |
| BSP rendering | 2.5D, e.g. Doom |
| conetracing | IO off |
| "dungeon crawler" | OO 2.5D, e.g. Eye of the Beholder |
| edge list, scanline, span rasterization | IO, e.g. Quake 1 |
| ellipsoid rasterization | OO, e.g. Ecstatica |
| flat-shaded 1 point perspective | OO 2.5D, e.g. Skyroads |
| reverse raytracing (photon tracing) | OO off, inefficient |
| image based rendering | generally using images as 3D data |
| light fields | image-based, similar to holography |
| mode 7 | IO 2.5D, e.g. F-Zero |
| parallax scrolling | 2.5D, very primitive |
| pathtracing | IO off, Monte Carlo, high realism |
| portal rendering | 2.5D, e.g. Duke3D |
| prerendered view angles | 2.5D, e.g. Iridion II (GBA) |
| raymarching | IO off, e.g. with SDFs |
| raytracing | IO off, recursive 3D raycasting |
| segmented road | OO 2.5D, e.g. Outrun |
| shear warp rednering | IO, volumetric |
| splatting | OO, rendering with 2D blobs |
| texture slicing | OO, volumetric, layering textures |
| triangle rasterization | OO, traditional in GPUs |
| voxel space rendering | IO 2.5D, e.g. Comanche |
| wireframe rendering | OO, just lines |
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)
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 are the 101 basics. Yes, you can use a 3D engine such as Godot with 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 :) You might as well ask ChatGPT to program it for you, right? So let's just foreshadow some concepts you should start with if you want to program your own 3D rendering.
Arguably the first, most elementary concept in 3D is that of perspective, or the effect by which "things further away look smaller". Practically speaking, this is the grand idea opening the door to start making simple 3D pictures, even though there are many more effects and concepts that eventually "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 to "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 require rotating camera and other fancy stuff, 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 will 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 exposure settings affect motion blur, what depth of field means, what HDR is etc.
You may have come here just to learn about the typical realtime 3D 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 is classified as 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 are projected onto the screen according to the position of the virtual camera and laws of perspective. Projecting the triangles means finding 2D screen coordinates of each of the triangle's three vertices (each of which has a 3D coordinate) -- once we have the 2D 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 incapable of handling 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 on top of that 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 (and mobiles, ...) 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 a kind of "bitch for everything", a general computing device usable 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 during 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.
To touch on something practical let's see what a typical pipeline might look like, similarly to something we might encounter 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:
WORK IN PROGRESS
{ This turned out to be long as hell, sowwy. ~drummyfish }
This is an example of how two very simple 3D models would be rendered using the traditional triangle rasterization pipeline. Note that this is VERY simplified, it's just to give you an idea of the whole process, BUT if you understand this you will basically get an understanding of it all.
Keep in mind this all can be done just with fixed point, floating point is NOT required.
First we need to say what conventions we'll stick to:
[x,y,z]. Some people rather use column vectors, which then means their matrices are also transposed and they do multiplication in opposite direction etcetc. Watch out about this, it's quite important to know which convention you're using, because e.g. matrix multiplication is non-commutative (i.e. with matrices A * B does NOT generally equal B * A) and the order you need to multiply in depends on this convention, so be careful.
Y ^ _
| _/| Z
| _/
|_/
'-------> X
Now let's have a simple 3D model data of a quad. Quad is basically just a square made of four vertices and two triangles, it will look like this:
quadModel:
v3________v2
| _/ |
| _/ |
| _/ |
|/_______|
v0 v1
In a computer this is represented with two arrays: vertices and triangles. Our vertices here are (notices all Z coordinates are zero, i.e. it is a 3D model but it's flat):
quadVertices:
v0 = [-1, -1, 0] v1 = [ 1, -1, 0] v2 = [ 1, 1, 0] v3 = [-1, 1, 0]
And our triangles are (they are indices to the vertex array, i.e. each triangle says which three vertices from the above array to connect to get the triangle):
quadTriangles:
t0 = [0,1,2] t1 = [0,2,3]
Note the triangles here (from our point of view) go counterclockwise -- this is called winding and is usually important because of so called backface culling -- the order of vertices basically determines which is the front side of the triangle and which is the back side, and rendering systems often just draw the front sides for efficiency (back faces are understood to be on the inside of objects and invisible).
Now the vertex coordinates of the model above are in so called model space -- these are the coordinates that are stored in the 3D model's file, it's the model's "default" state of coordinates. The concept of different spaces is also important because 3D rendering is a lot about just transforming coordinates between different spaces ("frames of reference"). We'll see that the coordinates in model space will later on be transformed to world space, view space, clip space, screen space etc.
OK, so next let's have 2 actual 3D model instances that use the above defined 3D model data. Notice the difference between 3D model DATA and 3D model INSTANCE: instance is simply one concrete, specific model that has its own place in the global 3D world (world space) and will be rendered, while data is just numbers in memory representing some 3D geometry etc. There can be several instances of the same 3D data (just like in OOP there can be multiple instances/objects of a class); this is very efficient because there can be just one 3D data (like a model of a car) and then many instances of it (like many cars in a virtual city). Our two model instances will be called quad0 and quad1.
Each model instance has its own transformation. Transformation says where the model is placed, how it's rotated, how it's scaled and so on -- different 3D engines may offer different kind of transformations, some may support things like flips, skews, non-uniform scaling, but usually at least three basic transforms are supported: translation (AKA offset, shift, position), rotation and scale. The transforms can be combined, e.g. a model can be shifted, rotated and scaled at the same time. Here we'll just rotate quad0 by 45 degrees (pi/4 radians) around Y (vertical) axis and translate quad1 one unit to the right and 2 back:
quad0:
[0,0,0]
[0,pi/4,0]quad1:
[1,0,2]
[0,0,0]So now we have two model instances in our world. For rendering we'll also need a camera -- the virtual window to our world. Camera is also a 3D object: it doesn't have 3D model data associated but it does have a transformation so that we can, naturally, adjust the view we want to render. Camera also has additional properties like field of view (FOV), aspect ratio (we'll just consider 1:1 here), near and far distances and so on. Our camera will just be shifted two units back (so that it can see the first quad that stays at position [0,0,0]):
camera:
[0,0,-2]
[0,0,0]It is important to mention the near and far planes. Imagine a camera placed at some point in space, looking in certain direction: the volume of space that it sees creates a kind of infinitely long pyramid (whose "steepness" depends on the camera field of view) with its tip at the point where the camera resides. Now for the purpose of rendering we define two planes, perpendicular to the camera's viewing direction, that are defined by the distance from the camera: the near plane (not surprisingly the one that's the nearer of the two) and the far plane. For example let's say our camera will have the near plane 1 unit in front of it and the far plane 5 units in front of it. These planes will CUT OFF anything that's in front and beyond them, so that only things that are BETWEEN the two planes will be rendered (you can notice this in games with render distance -- if this is not cleverly masked, you'll see things in the distance suddenly cut off from the view). These two planes will therefore CUT OFF the viewing pyramid so that now it's a six sided, finite-volume shape that looks like a box with the front side smaller than the back side. This is called the view frustum. Nothing outside this frustum will be rendered -- things will basically be sliced by the sides of this frustum.
You may ask WHY do we establish this frustum? Can't we just leave the near and far planes out and render "everything"? Well, firstly it's obvious that having a far cutoff view distance can help performance if you have a very complex model, but this is not the main reason why we have near and far planes. We basically have them for mathematical convenience -- as we'll see for example, perspective mapping means roughly "dividing by distance from camera" and if something was to be exactly where the camera is, we'd be dividing by zero! Attempting to render things that are just very near or on the back side of the camera would also do very nasty stuff. So that's why we have the near plane. In theory we might kind of get away with not having a strict far plane but it basically creates a nice finite-volume that will e.g. allow us to nicely map depth values for the z-buffer. Don't worry if this doesn't make much sense, this is just to say there ARE good reasons for this stuff.
Now let's summarize what we have with this top-down view of our world (the coordinates here are now world space):
Z
:
- - - - - - - 3 + - - - - - - - - far plane
:
:
2 +-----*------ quad2
:
:
1 +
: quad1
0 : _/
.|.....|.....*/....|.....|. X
-2 -1 _/: 1 2
. / : .
- - - - -'.=====:=====.'- - - - - near plane
'. : .'
'. : .'
-2 '*' camera
:
:
NOW actually let's see how to in fact render this. The big picture overview is this:
[0,0,0]) and is looking straight forward along the positive Z axis direction.
As seen this involves doing many transformations between different spaces. We do these using linear algebra, i.e. with vectors and matrices. Key things here are:
You HAVE TO learn how to multiply vector with matrix and matrix with matrix (it's not hard) else you will understand nothing now.
BIG BRAIN MOMENT: homogeneous coordinates. Please DO NOT ragequit, it looks complicated as hell (it is a little bit) but it makes sense in the end, OK? We have to learn what homogeneous coordinates are because we need them to be able to do all the awesome matrix stuff described above. In essence: in 3D space we can perform linear transformations with 3x3 matrices -- linear operations are for example scaling and rotation, BUT some, most importantly translation (shifting and object, which we absolutely NEED), are not linear (but rather affine) so they cannot be performed by a 3x3 matrix. But it turns out that if we use special kind of coordinates, we CAN do affine 3D transformations with 4x4 matrices, OK? These special coordinates are homogeneous coordinates, and they simply add one extra coordinate, w, to the original x, y and z, while it holds that multiplying all the x, y, z and w components by the same number does nothing with the point they represent. Let's show it like this:
If we have a 3D point [1,2,3], in homogeneous coordinates we can represent it as [1,2,3,1] or [2,4,6,2] or [3,6,9,3] and so on. That's easy no? So we will ONLY add an additional 1 at the end of our vertex coordinates and that's basically it.
Let's start doing this now!
Firstly let us transform quad0 from model space to world space. For this we construct so called model matrix based on the transformation that the model instance has. Our quad0 is just rotated by pi/4 radians and for this the matrix will look like this (you don't have to know why, you usually just look up the format of the matrix somewhere, but you can derive it, it's EZ):
quad0 model matrix:
| cos(A) 0 sin(A) 0| |0.7 0 0.7 0|
Mm0 = | 0 1 0 0| ~= |0 1 0 0|
|-sin(A) 0 cos(A) 0| |-0.7 0 0.7 0|
| 0 0 0 1| |0 0 0 1|
Let's see if this works, we'll try to multiply the first model vertex with this matrix (notice we add 1 at the end of the vertex, to convert it to homogeneous coordinates):
|0.7 0 0.7 0|
|0 1 0 0|
|-0.7 0 0.7 0|
|0 0 0 1|
v0 * Mm0 = [-1, -1, 0, 1] [-0.7 -1 -0.7 1] <-- result
So from [-1,-1,0] we got [-0.7,-1,-0.7] -- looking at the top-down view picture above this seem pretty correct (look at the coordinates of the first vertex). Try it also for the rest of the vertices. Now for the model matrix of quad1 (again, just look up what translation matrix looks like):
quad1 model matrix:
|1 0 0 0|
Mm1 = |0 1 0 0|
|0 0 1 0|
|1 0 2 1|
Here you can even see that multiplying a vector by this will just add 1 to x and 2 to z, right? Again, try it.
NEXT, the view matrix (matrix that will transform everything so that it's "in front of the camera") will basically just do the opposite transformation of that which the camera has. Imagine if you shift a camera 1 unit to the right -- that's as if the camera stands still and everything shifts 1 unit to the left. Pretty logical. So our view matrix looks like this (notice it just pushes everything by 2 to the front):
view matrix:
|1 0 0 0|
Mv = |0 1 0 0|
|0 0 1 0|
|0 0 2 1|
Then we'll need to apply perspective and get everything to the clip space. This will be done with so called projection matrix which will in essence make the x and y distances be divided by the z distance so that further away things will shrink and appear smaller. You can derive the view matrix, its values depend on the field of view, near and far plane etc., here we'll just copy paste numbers into a "template" for the projection matrix, so here it is:
projection matrix (n = near plane distance, f = far plane distance, r = right projection plane distance = 1, t = top projection plane distance = 1):
|n/r 0 0 0| |1 0 0 0|
Mp = |0 n/t 0 0| = |0 1 0 0|
|0 0 (f+n)/(f-n) 1| |0 0 3/2 1|
|0 0 -2*f*n/(f-n) 0| |0 0 -5/2 0|
This matrix will basically make the points so that their w coordinates will be such that when in the end we divide all components by it (to convert them back from homogeneous coordinates), we'll get the effect of the perspective (it's basically the "dividing by distance from the camera" that perspective does). That is what the homogeneous coordinates allow us to do. To visually demonstrate this, here is a small picture of how it reshapes the view frustum into the clip space box (it kind of "squishes" all in the back of the frustum pyramid and also squeezes everything to shape it into that little box of the clipping space, notice how the further away objects became closer together -- that's the perspective):
___________________ far plane _____________
\ A B C / | ABC |
\ / | |
\ D E F / | D E F |
\ / | |
\G H I/ |G H I|
\_______/ near plane |_____________|
: : : :
: : : screen :
: : : :
* camera
At this point we have the matrices of the individual transforms, but as we've said, we can combine them into a single matrix. First let's combine the view matrix and projection matrix into a single view-projection matrix by multiplying the two matrices (WATCH OUT: the order of multiplication matters here! It defines in which order the transformations are applied):
view-projection matrix:
|1 0 0 0|
Mvp = Mv * Mp = |0 1 0 0|
|0 0 3/2 1|
|0 0 1/2 2|
The rendering will begin with quad0, we'll combine its model matrix and the view-projection matrix into a single uber matrix that will just do the whole transformation for this model instance:
quad0 model-view-projection matrix:
|0.7 0 21/20 0.7|
Mm0vp = Mm0 * Mvp = |0 1 0 0 |
|-0.7 0 21/20 0.7|
|0 0 1/2 2 |
Now we'll just transform all of the model's vertices by multiplying with this matrix, and then we'll convert back from the homogeneous coordinates to "normal" coordinates by dividing all components by w (AKA "perspective divide") like this:
v0: [-1, -1, 0, 1] (matrix multiplication) => [-0.7, -1, -0.55, 1.3] (w divide) => [-0.53, -0.76, -0.43] v1: [ 1, -1, 0, 1] (matrix multiplication) => [ 0.7, -1, 1.55, 2.7] (w divide) => [ 0.26, -0.37, 0.57] v2: [ 1, 1, 0, 1] (matrix multiplication) => [ 0.7, 1, 1.55, 2.7] (w divide) => [ 0.26, 0.37, 0.57] v3: [-1, 1, 0, 1] (matrix multiplication) => [-0.7, 1, -0.55, 1.3] (w divide) => [-0.53, 0.76, -0.43]
And let's also do this for quad1.
quad1 model-view-projection matrix:
|1 0 0 0|
Mm1vp = Mm1 * Mvp = |0 1 0 0|
|0 0 3/2 1|
|0 0 7/2 4|
and
v0: [-1, -1, 0, 1] (matrix multiplication) => [-1, -1, 3.5, 4] (w divide) => [-0.25, -0.25, 0.87] v1: [ 1, -1, 0, 1] (matrix multiplication) => [ 1, -1, 3.5, 4] (w divide) => [ 0.25, -0.25, 0.87] v2: [ 1, 1, 0, 1] (matrix multiplication) => [ 1, 1, 3.5, 4] (w divide) => [ 0.25, 0.25, 0.87] v3: [-1, 1, 0, 1] (matrix multiplication) => [-1, 1, 3.5, 4] (w divide) => [-0.25, 0.25, 0.87]
Hmmm mkay let's draw the transformed points to an X/Y grid:
Y
|
[-1,1]|_______________:_______________[1,-1]
| |
| v3 +--.... |
| | '''---+ v2 |
| | .'| |
| |v3 +-----:--|+ v2 |
| | | .' ..|| |
--| | | :..' || |--
| | | '' || |
| |v0 +'-------|+ v1 |
| | : | |
| |.' ...---+ v1 |
| v0 +--'''' |
|_______________________________|___X
[-1,-1] : [1,-1]
HOLY SHIT IT'S 3D!!!11! Magic! In the front we see quad0, rotated slightly around the vertical (Y) axis, behind it is quad1, non-rotated but smaller because it's further away. This looks very, very good! We're almost there.
Also notice that the points -- now nicely projected onto a 2D X/Y plane -- still have 3 coordinates, i.e. they retain the Z coordinate which now holds their depth, or distance from the camera projection plane kind of. This depth is now in range from -1 (near plane) to 1 (far plane). The depth will be important in actually drawing pixels, to decide which are more in the front and therefore visible (this is the problem of visibility). The depth value can also be used for cool effects like the distance fog and so on.
The work up until now -- i.e. transforming the vertices with matrices -- is what vertex shaders do. Now comes the rasterization part -- here we literally draw triangles (as in individual pixels) between the points we have now mapped on the screen. In systems such as OpenGL This is usually done automatically, you don't have to care about rasterization, however you will have to write the algorithm if you're writing e.g. your own software renderer. Triangle rasterization isn't trivial, it has to be not only efficient but also deal with things such as not leaving holes between adjacent triangles, interpolating triangle attributes and so on. We won't dive deeper into this, let's just suppose we have a rasterization algorithm now. For example rasterizing the first triangle of quad0 may look like this:
_______________________________ | | | +--.... | | | '''---# | | | .## | | | +-----####+ | | | | .#####| | | | | :######| | | | | ########| | | | ##########+ | | | ########### | | | ############ | | ####### | |_______________________________|
During this rasterization process the Z coordinates of the mapped vertices are important -- the rasterizer interpolates the depth at the vertices, so it knows the depth of each pixel it creates. This depth is written into so called z-buffer (AKA depth buffer) -- basically an off-screen buffer that stores one numeric value (the depth) for each pixel. Now when let's say the first triangle of quad1 starts to be rasterized, the algorithm compares the rasterized pixel's depth to that stored on the same position in the z-buffer -- if the z-buffer value is small, the new pixel mustn't be drawn because it's covered by a previous drawn pixel already (here probably that of the triangle shown in the picture).
So the rasterization algorithm just shits out individual pixels and hands them over to the fragment shader (AKA pixel shader). Fragment is a program that just takes a pixel and says what color it should have (basically) -- this is called shading. For this the rasterizer also hands over additional info to the fragment shader which may include: the X/Y coordinates of the pixel, its interpolated depth (that used in z-buffer), vertex normals, ID of the model and triangle and, very importantly, the barycentric coordinates. These are three-component coordinates that say where exactly the pixel is in the triangle. These are used mainly for texturing, i.e. if the model we're rendering has a texture map (so called UV map) and a bitmap image (texture), the fragment shader will use the UV map and barycentric coords to compute the exact pixel of the texture that the rasterized pixel falls onto AND this will be the pixel's color. Well, not yet actually, there are more things such as lighting, i.e. determining what brightness the pixel should have depending on how the triangle is angled towards scene lights (for which we need the normals), how far away from them it is, what colors the lights have etcetc. And this is not nearly all, there are TONS and tons of other things, for example the interpolation done by rasterizer has to do perspective correction (linearly interpolating in screen space looks awkward), then there is texture filtering to prevent aliasing (see e.g. mipmapping, transparency, effects like bump mapping, environment mapping, screen space effects, stencil buffer etcetc. -- you can read whole books about this. That's beyond the scope of this humble tutorial -- in simple renderers you can get away with ignoring a lot of this stuff, you can just draw triangles filled with constant color, or even just draw lines to get a wireframe renderer, all is up to you. But you can see it is a bit bloated if everything is to be done correctly -- don't forget there also exist other ways of rendering, see for example raytracing which is kind of easier.
"It is not that uncommon for the cost of an abstraction to outweigh the benefit it delivers. Kill one today!"" -- John Carmack, 2012
Abstraction (from Latin abstraho, to draw away) is an important concept in programming, mathematics and other fields of science, philosophy and art, which in simple terms means "viewing something from a distance", "zooming out", thinking in higher-level concepts, paying less attention to fine detail so that one can better see the bigger picture. With respect to the real world abstraction is the degree (and way) of its simplification ("we neglect this and that"), generalization ("we pretend everything obeys this and that") and alienation ("we accept in these certain ways reality is nothing like our abstraction"). In traditional science (including mathematics) abstraction is related to mathematical models, i.e. systems that resemble reality (and are thus useful for making predictions about reality) but are inevitably simpler (abstract), therefore not completely accurate. In programming 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 are related to them only very distantly, and so abstract paintings often don't resemble anything concrete or clearly 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. Similarly a man walking in a forest, being able to clearly distinguish vegetation around him, thinks in terms of individual trees, bushes and rocks -- he perceives different kinds and sizes of them and plans his actions based on this perception. A cartographer on the other hand rather views the land from a plane at high altitude and sees only a big green blob he calls a "forest", he no longer cares about individual trees, his maps record only borders of this big, abstract entity. The term "high altitude overview" is commonly used in speech: for example scientific papers always begin with so called abstract, a short "high altitude" overview and summary of the paper.
Mathematics is a discipline best exemplifying abstraction: it deals purely with abstract concepts. Initially this abstraction is mild -- numbers and sets for example -- and the more it advances, the deeper and harder to grasp the abstraction becomes, towards difficult to imagine concepts such as differential equations, categories, quaternions, different types of infinities, decidability etc. Some subjects go as far to almost lose any connection with the real world, leaving us completely without any intuition or a way to even visualize what we're dealing with. Ever growing abstraction is probably the inevitable purpose and objective of mathematics, but now let's rather ask how abstraction relates to programming.
In programming we have to be more careful: abstraction here means basically "making stuff easier by hiding and ignoring lower levels of abstraction", i.e. making libraries, languages and other tools that facilitate work with the astronomically complex computer hardware. 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 allows them to quickly learn to do poorly what should be done properly, 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. Abstraction is useful but what's happening here is twisting its meaning: instead of ignoring details where it's acceptable and useful, abstraction is now used as an excuse meaning ignorance of details, i.e. whereas originally a programmer knew the details and would decide to ignore them where it's of benefit, nowadays the programmer doesn't know the details at all because he thinks he is allowed to by the existence of abstraction, and so he ignores them in any situation. This is BAD. It is basically why technology has been on such a huge downfall in the latest decades and why so many incompetent people flooded the industry. 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 only have as much abstraction as to allow portability, it should definitely NOT resort to high abstraction such as object obsessed programming.
Bill Gates allegedly said that abstraction layers are like condoms, "you should wear at least 3". We say sure, if you're a noob virgin then that is "safe". If you're a pro pornstar who can control his cum, you wear no condom, you pay no money and waste no time, and as a bonus the sex is actually enjoyable.
Upon closer inspection we find that 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):
Poor man's Doom?
Anarch is a LRS/suckless, free as in freedom (public domain) first man shooter game similar to Doom, created completely from scratch 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. Anarch got 78 stars on gitlab and 42 stars on codeberg before being banned due to author's political opinions.
There are now also additional official mods available for the game that for example add multiplayer, increase texture resolution, improve the overall look, allow recording demos, replace assets with those from Freedoom and so on.
To make Anarch no advanced bullshit was used such as multiple monitors, IDEs, UML, workstations, graphic tablets, programming socks, budget, expensive chairs and so on. It was made mostly with one old laptop, one old desktop computer and only basic free software such as vim, GIMP and so on.
The repo is available for example at https://git.coom.tech/drummyfish/Anarch. Some info about the game can also be found at the libregamewiki: https://libregamewiki.org/Anarch. The 1.0 version was released on 1st December 2020 after some 757 commits in the repository, it was officially in the making since September 25 2019 (first commit in the repo), but we may also see the inception of the game to be the start of raycastlib development in 2018.
{ Someone told me the game even briefly appeared on TV: some Croatian TV station covered the country's startup (I reckon it was Circuitmess) which creates open consoles, and they showed one of them running Anarch. Pretty cool. Anarch was also briefly played by Muta from SomeOrdinaryGamers, a quite famous YouTube channel, in a video covering the worst websites on the Internet. I now also found it on F-Droid :-) Now also on Grokipedia: https://grokipedia.com/page/anarch-video-game. ~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
The following are some of the game's features:
Upon release the game garnered some attention at 4chan/g -- of course this included suggestions for drummyfish to kill himself, but generally anons seemed to like it, at least for the overall autism.
{ MINI DRAMA SECTION: I want to apologize here for mentioning that I found the game selling on Switch store and assuming it was a cash grab scam, I actually got an email from the developer and got a very nice donation. Thank you <3 EDIT2: I am an idiot. I probably fucked up the previous statement too as I got an email from a friend who asked me if this is a sell out, and I now absolutely see it looks that way, so please let me clarify this: I do not approve of proprietary software or selling software for money, I also hate Nintendo Switch etc., hopefully that's clear. What happened was that the developer emailed me beforehand asking if he could make the port, if I wanted to be credited and if I would accept a donation, and this alone is very nice of him (despite me still holding my beliefs about selling software etc.) because it's pretty clear he can make the port without asking me or paying me anything. I responded he can of course make the port and that donations and credit are always optional and there is not even any moral pressure to make them (i.e. not only I don't require them, I don't even expect them), i.e. basically what I state on my website. He then made the port and sent me a nice donation (which may be even more than what the port will make, i.e. it's clearly not a blatant cash grab), but later on someone sent me a link to the port on Switch store and of course like a dumbass I am I FORGOT about the email (one of very many I get) and so I assumed it was some kinda "scam" (which would still be legally fine of course) and made a comment about it in some places, and this was a BIG FUCKUP by me because I gave the guy a thumbs up and then behaved as if I didn't, and this I am very deeply sorry for. I.e. this wasn't me suddenly approving of a commercial port or changing my opinions upon receiving money, it was just me accidentally behaving like a dick, which is what I want to apologize for. ~drummyfish }
The game was met with overwhelmingly mixed reception with professional Internet forum posters mostly judging it shit, some however still appreciated it especially for its superiority over every other game. One reviewer from an expert technology forum described it as: "kill yourself". On Metacritic the game didn't achieve any score but someone made a Wikidata item for it. During the first 5 years the game's grand total sales through itch.io's pay what you want system reached nearly $35 (before tax). This covered the development costs approximately infinitely many times.
Some fun facts about the game include:
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.
written by drummyfish
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 and for what it is overall, it got some attention among the niche of suckless lovers and many people have written me they liked the game and its philosophy. It's not nearly a peak of minimalism or highest LRS ideal, but definitely shows how mixing minimalism into a project can make it so much nicer. Many people have ported Anarch to their favorite platforms, some have even written me their own expansions of the game lore, tricks they found etc. Some even created small mods. If you're among them, thank you :)
There were also a few people I've heard criticism from -- and that's absolutely fine -- that the game is just shit, too simple, badly designed, boring and so on. Indeed, about the quality of the game as such (from the "consumer's" point of view) I actually agree, the game isn't the most fun one to play, but when judging it please keep in mind the following. Firstly it was ALL made by a single man, absolutely from scratch -- if you've ever tried to create something from nothing, you know that despite it not looking that hard, it is indeed extremely difficult and time consuming to make something from the ground up, AND I couldn't even use any free assets, sound samples, game engines, not even fonts -- except for the programming language I had to create EVERYTHING from nothing, which required not only great amount of time, but also skills which I cannot master all: that of a visual artist, engineer, level designer, sound artist and so on and so forth. You only see the result but not the dozens of blind paths, hundreds of lines of rewritten code that was thrown to trash, hours and hours spent hunting down silly little bugs. All the skills needed for making a complete game are so vastly different that unless one is a genius, they cannot be mastered at once, one would simply have to be an excellent painter, writer, musician, mathematician, programmer, psychologist and many different things at once. Secondly I didn't work on it full time, I worked on other things, went to work, I was even hospitalized etc. Thirdly the goal wasn't to make a game that would be excellent by its gameplay AT ALL, the context of its creation was absolutely different from that of a typical game that has to try to appeal to many people, Anarch was focused on showing the technological side, prove a point of a certain development philosophy, and that mostly to rather a few people who want to make games themselves. By its philosophy it's also not meant to be a "fixed product" as is, again, common to think of games nowadays, it is really meant to be a basis for improvement, mods, a starting codebase for forks and so on. So even though there are many shortcomings and things done plainly wrong, I think the main goal was more or less achieved, though some people miss to see that goal. If this philosophy of simplicity allows a single guy (quite average and in many ways retarded and that) to make a WHOLE game completely from scratch, with zero budget, only over weekend evenings, and that game is additionally very well made (extremely small, portable, modifiable, free, ...), what if let's say three brilliant people worked on it? What if five people worked on something similar full time? What marvels would we see? This is the number one question I wanted to highlight.
The following is a retrospective look on what could have been done better (a potential project for someone might be to implement these and so make the game even more awesome):
SFG_recomputePlayerDirection was an attempt at optimization but it's probably optimization in a wrong place that does nothing, ...
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
The "random dot" technique gives rise to an especially interesting type of autostereogram -- one whose creation can easily be automated 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;
}
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 undoubtedly 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).
Here we'll summarize the common rules, please keep in mind there may exist 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 mental calculations as chess for example, 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).
Despite chance playing some role, skill is highly important and there exist strategies and tactics that maximize one's 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.
It's quite good.
TODO: moar, lulz in backgammon?
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 and popularly encountered e.g. in 3D computer graphics as a method of texture filtering; bilinear interpolation allows for upscaling textures to higher resolutions (i.e. insert new pixels in between existing pixels) whilst 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 come with bilinear filtering built-in as a standard feature (e.g. GL_LINEAR in OpenGL). Of course this method is not limited to upscaling textures and can be applied to any set of discrete samples such as terrain heightmaps or any kind of discrete mathematical function which we want to automatically generalize to all real numbers, it's not something encountered only in computer graphics, even though this article will still mostly view it from the graphics perspective.
Why is it named bilinear? Probably because it's doing linear interpolation twice: once in X direction, then in Y direction.
####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. Similarly 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
For suckless programs that do their own software rendering an issue of bilinear interpolation, as compared with nearest neighbor, might be that it creates new colors by averaging colors in the filtered image, i.e. image filtered this way may have new colors introduced and this may become a problem e.g. if we are using palettes (indexed mode) with limited number of colors and possible operations with them. This may also complicated e.g. using precomputed scaling tables (used in old games like wolf 3D) that simply store mapping of the original image to pixels in an upscaled image. A possible attempt at a "fix" -- or rather more of a poor man's bilinear interpolation -- may be in dithering the colors rather than averaging; perhaps once we sample in between pixels we assign probabilities to the 4 nearest pixels, based on their distance to the sample position, and then take one of the four pixels at random with those probabilities using some pseudorandom generator.
TODO: test the above
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 as 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:
Of course the binary system didn't appear out of thin air one day, people have known and used similar systems since ancient times, 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 hardly anyone cared. Nowadays the binary system is very popular and in the center of attention thanks to the success and utility of computers.
{ 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 }
For more detail see also logic gate.
In binary we start by working with single bits -- each bit is like a small space that can hold exactly one of two possible values: 1 or 0, just like a light switch can be either on or off. At this point we can imagine bits like very simple numbers, and so naturally we'll want to start performing "operations" with them just like we are used to with ordinary numbers (What would numbers be good for if we weren't able to add or multiply them together?), but it will still hold that bits can only ever hold one of the two values, 0 or 1, so it's naturally going to be a bit different, we have to think about what happens if we add two 1s together and so on. Though we can interpret what the 0 and 1 values mean in any way -- e.g. in electronics as high vs low voltage -- in mathematics we traditionally turn to go along with logic and interpret them as true (1) and false (0). This interpretation is nice because math already has a lot of knowledge about laws of logic and this will transfer nicely to what we're doing now, so for example we'll be able to use various formulas that are already well known and proven to work.
Next we want to define said "operations" with bits -- for this we use so called Boolean algebra, which is originally a type of abstract algebra that works with sets and operations such as conjunction, disjunction etc. Boolean algebra can be viewed 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 kinds of operations such as logical AND (similar to multiplication), logical OR (similar to addition) and so on. Generally Boolean algebra can operate with more than just two values (0 and 1), however that's more interesting to mathematicians; for us all we need now is a binary Boolean algebra -- that's what programmers have adopted. It is the case that in context of computers and programming we implicitly assume 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". Many programming languages have a data type called boolean or bool that allows representing just two values (true and false).
The very basic operations, or now we would rather say Boolean functions, are:
!): Performed on a single bit, turns 1 into 0 and vice versa.
/\): Performed on 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) .
\/): Performed on 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):
| x | y | NOT x | x AND y | x OR y | x XOR y | x NAND y | x NOR y | x NXOR y |
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 1 |
| 0 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 0 |
| 1 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 |
| 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 1 |
In fact there exists more functions with two inputs and one output (16 in total, verifying this is left as an exercise :]). However not all have commonly established names -- we only use special names for the frequently used ones, mostly the ones in the table above.
A curious fact is that we may only need one or two of these functions to be able to create all the other functions as well (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:
x AND 0 = 0
x OR 1 = 1
x AND 1 = x
x OR 0 = x
x AND x = x
x OR x = x
x OR y = y OR x
x AND y = y AND x
x OR (x OR x) = (x OR x) OR x
x AND (x AND x) = (x AND x) AND x
x AND (y OR z) = (x AND y) OR (x AND z)
x OR (y AND z) = (x OR y) AND (x OR z)
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 go on and construct not only operations with whole numbers and the traditional algebra we know from school, but also a whole computer that renders 3D graphics and sends multimedia over the Internet. This is done by grouping multiple bits together to create a base-2 numeral system (described below), i.e. we'll go from working with single bits to working with GROUPS of bits -- single bits only allow us to represent two values, but a group of bits will allow us to store more. For example a group of 8 bits (byte) lets us represent 256 distinct values, which we may interpret as whole numbers: 0 to 255. Now using the elementary functions shown above we can implement all the traditional operators for addition, subtraction, multiplication, division, ... and that's not all; we can go yet further and implement negative numbers, fractions, later on strings of text, and we can go on and on until we have a very powerful system for computation. For more detail see logic gates and logic circuits.
While we may use a single bit to represent two values, we can group more bits together and so gain the ability 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 (with 4 bits):
| decimal | binary |
|---|---|
| 0 | 0000 |
| 1 | 0001 |
| 2 | 0010 |
| 3 | 0011 |
| 4 | 0100 |
| 5 | 0101 |
| 6 | 0110 |
| 7 | 0111 |
| 8 | 1000 |
| ... | ... |
Conversion to decimal: let's see an example demonstrating things 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 essentially the same, save for the fact that we only use two digits instead of 10. For example to add 22 (10110 in binary) and 11 (1011 in binary) we keep adding the digits in corresponding columns from right to left and whenever we add two 1s, we carry over a 1 to the next column:
10110 + 22 in decimal 1011 11 in decimal _____ 100001 33 in decimal
It is easy to deduce and check that to implement binary addition (for instance as a hardware adder for a CPU) we only need a XOR logic gate (to add individual bits), AND logic gate (to compute carry) and binary shift to the left. If we have bitwise XOR and AND, then to add two numbers we'll need at most as many steps as there are "columns", i.e. bits in our numbers. Each step will involve XORing the numbers to get a new sum, ANDing them to get carry bits and shifting the carry bits to the left, which will give us a new number to subsequently be adding in the next step. We can demonstrate this again by adding the same numbers as above:
10110 + <-- A (22)
01011 <-- B (11)
_____
STEP 1:
11101 <-- A2 = add, A XOR B
00010 <-- carry, A AND B
00100 <-- B2 = carry shifted left
_____
STEP 2:
11001 <-- A3 = add, A2 XOR B2
00100 <-- carry, A2 AND B2
01000 <-- B3 = carry shifted left
_____
STEP 3:
10001 <-- A4 = add, A3 XOR B3
01000 <-- carry, A3 AND B3
10000 <-- B4 = carry shifted left
_____
00001 <-- A5 = add, A4 XOR B4
10000 <-- carry, A4 AND B4
100000 <-- B5 = carry shifted left
______
100001 <-- A6 = add, A5 XOR B5
000000 <-- carry, A5 AND B5; it's all 0s so we can stop now
______
100001 <-- A6 is our result
Subtraction works similarly but is a tiny bit more complicated (we use "borrows" instead of carry), however we can get around this by using a simple trick. Subtracting means adding a negative number, so we can use two's complement encoding to negate the number we want to subtract and then use the plain and simple addition algorithm. As an example let's take 18 (10010) minus 6 (00110): by definition in two's complement we can negate the number 6 by flipping all the bits (to get 11001) and adding 1 (to get 11010), and then we simply add:
10010 + 18 in decimal 11010 -6 in decimal _____ 01100 12 in decimal
Another example may be multiplication of 110 (6) by 11 (3) to get 10010 (18):
110 * 6 in decimal 11 3 in decimal ___ 110 110 ____ 10010 18 in decimal
All of these operations can be implemented just using the basic boolean functions described in the section above -- 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 simple 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 prefer to use hexadecimal and octal to decimal.
0 1 2 3 4 5 6 7 8 9 A B C D E F
0 ] ] '] ' ] ''] ' ] ' '] '' ] ''']' ]' ']' ' ]' '']'' ]'' ']''' ]'''']
1 ] .] :] '.] ':] ' .] ' :] ''.] '':]' .]' :]' '.]' ':]'' .]'' :]'''.]''':]
2 ] . ] .'] : ] :'] '. ] '.'] ': ] ':']' . ]' .']' : ]' :']''. ]''.']'': ]'':']
3 ] ..] .:] :.] ::] '..] '.:] ':.] '::]' ..]' .:]' :.]' ::]''..]''.:]'':.]''::]
4 ] . ] . '] .' ] .''] : ] : '] :' ] :'']'. ]'. ']'.' ]'.'']': ]': ']':' ]':'']
5 ] . .] . :] .'.] .':] : .] : :] :'.] :':]'. .]'. :]'.'.]'.':]': .]': :]':'.]':':]
6 ] .. ] ..'] .: ] .:'] :. ] :.'] :: ] ::']'.. ]'..']'.: ]'.:']':. ]':.']':: ]'::']
7 ] ...] ..:] .:.] .::] :..] :.:] ::.] :::]'...]'..:]'.:.]'.::]':..]':.:]'::.]':::]
8 ]. ]. ']. ' ]. ''].' ].' '].'' ].''']: ]: ']: ' ]: '']:' ]:' ']:'' ]:''']
9 ]. .]. :]. '.]. ':].' .].' :].''.].'':]: .]: :]: '.]: ':]:' .]:' :]:''.]:'':]
A ]. . ]. .']. : ]. :'].'. ].'.'].': ].':']: . ]: .']: : ]: :']:'. ]:'.']:': ]:':']
B ]. ..]. .:]. :.]. ::].'..].'.:].':.].'::]: ..]: .:]: :.]: ::]:'..]:'.:]:':.]:'::]
C ].. ].. ']..' ]..''].: ].: '].:' ].:'']:. ]:. ']:.' ]:.'']:: ]:: ']::' ]::'']
D ].. .].. :]..'.]..':].: .].: :].:'.].:':]:. .]:. :]:.'.]:.':]:: .]:: :]::'.]::':]
E ]... ]...']..: ]..:'].:. ].:.'].:: ].::']:.. ]:..']:.: ]:.:']::. ]::.']::: ]:::']
F ]....]...:]..:.]..::].:..].:.:].::.].:::]:...]:..:]:.:.]:.::]::..]::.:]:::.]::::]
All possible 8 bit values (corresponding exactly to 2 hexadecimal digits) in a table where rows and columns represent the lower and higher hexadecimal digits respectively. Each 8 bit value is represented by a tiny "4x2" ASCII image where bottom shows the lower 4 bits and top the higher 4 bits (e.g. '.:. means 10100111, or A7 in hexadecimal).
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:
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.
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 -- then yet higher units such as kilobyte and megabyte are constructed from there. 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.
Bit hacks (also bit tricks, bit magic, bit twiddling, bit rape 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; most notable may however be the chapter 7.1.3. (Bitwise Tricks and Techniques) of Volume 4 of The Art of Computer Programming.
Basic bit manipulation techniques are common and part of general knowledge so they won't be listed under "true" hacks, but for the sake of completeness and beginners reading this we should dedicate them at least a short summary. 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 a 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 for checking 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 for instance to flip specific selected bits (you can think of X XOR Y as an operation that flips the bit of X if the Y bit is 1, otherwise the bit stays the same).
<< 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 for performing 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. Shifts also allow us to iterate over individual bits, e.g.: int ones = 0; while (x) { ones += x & 0x01; x >>= 1; }.
&& (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 (even negative) to be true (and always returning value 1 as true), and secondly they may employ a bit more complexity, e.g. short circuit evaluation.
+, * and so on, but that's less common.{ 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 assume 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. Bear in mind all potential dangers, for example it may sometimes be better to write an idiomatic code and let the compiler do the optimization that's best for given platform, also of course readability may suffer from hacks 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): x - ((x + x) & (0 - (x < 0))); or
int t = x >> (sizeof(x) * 8 - 1); x = (x + t) ^ t;
add y to x without arithmetic operators (leaves carry in y): while (y) { x = x ^ y; y = ((x ^ y) & y) << 1; } or (using extra variable but saving cycles) while (y) { c = x & y; x = x ^ y; y = c << 1; }
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, or etc.) x and y based on condition c (c is 0 or 1): x + (y & (0 - c)) or x + (y & ~(c - 1)), this avoids branches AND ALSO multiplication by c, of course you may replace + by other 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.
expand lowest bit (two's complement) (i.e. 0 to all 0s and 1 to all 1s): ~(x - 1) or 0 - x
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. Also int log2 = 0; while (x >>= 1) { log2++; }
minimum of x and y: x ^ ((0 - (x > y)) & (x ^ y)) or y ^ ((x^y) &((x-y) >> (8 * sizeof(int) - 1)))
maximum of x and y: x ^ ((0 - (x < y)) & (x ^ y)) or x ^ ((x^y) &((x-y) >> (8 * sizeof(int) - 1)))
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 temporary variable): 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?
Bloat is a very broad 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, redundant code, unnecessary and/or useless features (e.g. feature creep) and use of computational resources (memory, CPU time, electricity, ...), all of which lead to inefficient, badly designed, unstable, hard to maintain and downright dangerous technology littered with bugs (crashes, unusable features, memory leaks, security vulnerabilities, ...), obscurity, ugliness, further leading to loss of freedom and waste of human effort. In simpler words: bloat is burdening bullshit so to speak. Bloat is immensely bad and one of the most prominent technological issues of today. For an individual, be it programmer or user, to deal with bloat is always a sickening descent into madness and for a programmer to participate in creation of bloat is not just shameful, but shows obnoxiously shitty engineering at its worst and complete lack of understanding of basic philosophy of technology. And yet bloat prospers and stains not just 100% of mainstream programs (commercial or not), but also the better majority of non-mainstream projects seeking to be engineered well. Bloat is what has completely taken over all technology nowadays, it has now reached galactic proportions mostly due to capitalism induced commercialization, consumerism, rushed "just works" products, creating demand for newer hardware and so on, and also pushing incompetent people (women, minorities etc.) to do work they lack mental capacity for.
A related but technically distinct 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 (and often uninstallable) etc. Further on we'll rather focus on bloat as defined before.
A bit of history: overcomplicated and obfuscated technology has always been known to suck, however it seems like only with the arrival of personal computers it started to become a world wide cancer and absolutely serious threat to society. Some dictionaries date the first use of the word bloatware to the beginning of 1990s, around the time when mainstreamization of computers began (web, Doom, Windows, ...), specifically 1991 by Business Week. Goolag trends for terms bloatware and software bloat show an increased search frequency since the year 2010 (which we see more or less as the year when the downfall of society started) and peak around 2015. As for the term bloat itself it's hard to find the exact moment at which it started to be used in today's sense, the word bloat is a normal word and has likely been used in computer speech since the dawn of computer era, though originally (judging by some 1989 usenet posts) more for "files getting big", "email box getting clogged" etc., however by 2007 the suckless website already talks about bloated software as in "overly complex source code with bullshit features".
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 brief overview let us average some data over time -- the table that follows shows growth of system requirements and averages them to arrive at some estimate of bloat ratio with respect to the first row (time). 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 that usage of our computing resources grew over 2000 times despite computers even generally behaving slower and less responsively from the user's perspective. Indeed, video games have much more "advanced" visuals and websites offer more functionality than in 1990s, but ask yourself: is an AVERAGE website (i.e. most likely just a bunch of text) 2000 times more informative and useful now? Is an AVERAGE video game 2000 times prettier (NOT advanced, but aesthetically more pleasing) and that many times as much fun than back then? Couldn't we back then do in essence the very same things (communicate, have fun, record events, ...), just 2000 times more efficiently?
| year | avg. webpage size (KB) | Windows min RAM MB/CPU MHz/HDD MB | Debian min RAM MB/HDD MB | FPS game min RAM MB/CPU MHz/HDD MB | Blender (win zip KB) | % of base |
|---|---|---|---|---|---|---|
| 1993 | 4 | 3, 25, 9 | 4, 20 | 4, 30, 24 (Doom) | 100 (extrap.) | 100 |
| 1994 | 8 | 3, 25, 9 | 4, 20 | 4, 33, 15 (Heretic) | 172 | 114 |
| 1995 | 14 | 12, 25, 90 | 4, 20 | 4, 33, 16 (Descent) | 307 | 263 |
| 1996 | 23 | 16, 33, 128 | 4, 80 | 8, 66, 25 (Duke Nukem 3D) | 442 | 412 |
| 1997 | 34 | 16, 33, 128 | 4, 90 | 16, 90, 25 (Quake II) | 577 | 486 |
| 1998 | 44 | 16, 33, 128 | 4, 90 | 24, 133, 400 (Half Life) | 712 | 715 |
| 1999 | 53 | 32, 133, 1000 | 5, 100 | 64, 233, 70, 8M GPU (Quake III) | 849 | 1817 |
| 2000 | 63 | 32, 133, 1000 | 5, 100 | 32, 233, 200, 4M GPU (Daikatana) | 1170 | 1848 |
| 2001 | 74 | 64, 233, 1500 | 5, 100 | 64, 300, 600, OGL GPU (Serious Sam) | 1323 | 2863 |
| 2002 | 83 | 64, 233, 1500 | 12, 110 | 256, 500, 2000, 32M GPU (UT 2003) | 1501 | 4055 |
| 2003 | 93 | 64, 233, 1500 | 12, 120 | 128, 600, 1400, 32M GPU (COD) | 1704 | 3569 |
| 2004 | 115 | 64, 233, 1500 | 12, 150 | 256, 1200, 6000, DX7 GPU (HL2) | 4399 | 6345 |
| 2005 | 189 | 64, 233, 1500 | 24, 450 | 512, 1700, 5000, 64M GPU (FEAR) | 6353 | 7296 |
| 2006 | 212 | 384, 800, 15000 | 24, 450 | 512, 2000, 2000, 64M GPU (Prey) | 7277 | 22589 |
| 2007 | 260 | 384, 800, 15000 | 64, 1000 | 1024, 2000, 12000, 64M GPU (Crysis) | 8639 | 28667 |
| 2008 | 312 | 384, 800, 15000 | 64, 1000 | 1024, 2600, 12000, 256M GPU (FC2) | 12778 | 29411 |
| 2009 | 443 | 1024, 1000, 16000 | 64, 1000 | 2048, 2400, 13000, 128M GPU (LFD2) | 13683 | 36063 |
| 2010 | 481 | 1024, 1000, 16000 | 64, 1000 | 2048, 2400, 11000, 256M GPU (BS2) | 25059 | 36462 |
| 2011 | 657 | 1024, 1000, 16000 | 64, 1000 | 2048, 3000, 8000, 128M GPU (Portal2) | 32398 | 36586 |
| 2012 | 831 | 1024, 1000, 16000 | 64, 1000 | 2048, 2600, 15000, 512M GPU (FC3) | 45786 | 41143 |
| 2013 | 1102 | 1024, 1000, 16000 | 64, 1000 | 3000, 2400, 17000, 1G GPU (Crysis 3) | 67787 | 47168 |
| 2014 | 1249 | 1024, 1000, 16000 | 64, 1000 | 4096, 2600, 30000, 1G GPU (FC4) | 81676 | 57147 |
| 2015 | 1466 | 1024, 1000, 32000 | 128, 2000 | 6000, 2900, 60000, 1G GPU (CODBO3) | 104139 | 95734 |
| 2016 | 1502 | 4096, 1000, 64000 | 128, 2000 | 8192, 3100, 45000, 2G GPU (Doom2016) | 107840 | 141286 |
| 2017 | 1681 | 4096, 1000, 64000 | 128, 2000 | 8192, 3300, 90000, 2G GPU (CODWW2) | 116121 | 161379 |
| 2018 | 1848 | 4096, 1000, 64000 | 128, 2000 | 8192, 3100, 40000, 2G GPU (FC5) | 113915 | 140675 |
| 2019 | 1980 | 4096, 1000, 64000 | 550, 850 | 6000, 3400, 75000, 2G GPU (BL3) | 153290 | 154626 |
| 2020 | 2042 | 4096, 1000, 64000 | 550, 850 | 8192, 3100, 50000, 4G GPU (Doom: E) | 197632 | 154179 |
| 2021 | 2173 | 4096, 1000, 64000 | 780, 920 | 8192, 3100, 60000, 4G GPU (FC6) | 221865 | 161706 |
| 2022 | 2280 | 4096, 1000, 64000 | 780, 920 | 8192, 3300, 125000, 2G GPU (CODMWF2) | 248477 | 191785 |
| 2023 | 2484 | 4096, 1000, 64000 | 780, 1184 | 8192, 3300, 150000, 2G GPU (CODMWF3) | 400653 | 207980 |
| 2024 | 2500 | 4096, 1000, 64000 | 780, 1184 | 8192, 3200, 102000, 2G GPU (CODBO6) | 403458 | 195260 |
| 2025 | 2650 | 4096, 1000, 64000 | 920, 794 | 16384, 3600, 100000 (Doom DA) | 413902 | 211460 |
One of 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 -- see freedom distance). Once a piece of software becomes very large, it starts to require full time developers, meaning someone has to stop working and dedicate all his time to the project, meaning he has to make money from developing it and here money enter the scene, sponsors come in, ads start to appear, data start being collected and once the business (even one based around a "FOSS" project) is established, forks become undesirable, inviting in a creeping obscurity, incompatibility, lock-ins and other obstacles (despite a free license) etcetc. { I recently noticed in the so called "open source" Firefox browser that "sponsored" links start appearing at the blank page :) ~drummyfish } A more bloated program won't run on simpler (older, cheaper, homemade, ...) computers, effectively limiting the freedom to use the program, forcing the user to run it on a mainstream (unethical, expensive, spying, abusive, consumerist, power hungry, shitty, ...) computer etc. 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
|(may: : ____... .
luxury | be): : ___________/
| : : ________/
| : __:___/ \__________
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 do note there may arise disagreements among minimalist groups about where the line 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):
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 }
The list in this section shows examples of software usually considered a well illustrative 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.
Some of said programs may be replaced with smaller bloat that does practically the same job (e.g. in terms of output) just with less bullshit around (e.g. with simpler GUI, or no GUI at all), 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 such a result is then a mistake in itself, committed usually by beginners and minimalist newcomers, the same as wanting to achieve the "Windows experience" on a GNU system for example. 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 do away with bloat one must learn to live only with minimalist programs and need only results they can produce; that means unlearning the "bigger = better" doctrine, one has to understand that minimal results themselves are superior AND in addition allow using superior programs (i.e. minimal ones).
Besides the typical big programs that even normies admit are bloated there exists also a smaller bloat which most humanoids probably don't identify as such but that is nonetheless still considered unnecessarily complex by experts and/or idealists and/or hardcore minimalists, including us.
Small bloat has traditionally been a subject of popular jokes such as "OMG he uses a Unicode font -- BLOAT!!!!!"". These are good jokes, it's healthy 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. Having categorized something as small bloat doesn't necessarily imply us having to completely avoid and reject the thing or concept, we may just try to mitigate the impact, for example by making it an optional choice. In context of today's PCs using a Unicode font is not really an issue for performance, memory consumption or anything in these terms, but we should keep in mind it may not be so on much weaker computers or for example post-collapse computers, and using Unicode implies someone has to make and maintain the Unicode standard, which IS a tedious, difficult and resource hungry task for humans, so we should try to design systems that don't depend on Unicode if at all possible.
Also please remember that relatively small libraries for things that are easily done without a library, such as fixed point arithmetic, are also bloat. This is a case of pseudominimalism.
Small/medium bloat includes for example:
The concept of bloat can be applied even outside the computing world, to non-computer technology and even non-technological subjects such as art, culture or law. Here it becomes kind of synonymous with bullshit, but using the word bloat says we're viewing the issue through the lens of someone acquainted with computer bloat. Examples include:
See also life minimalism.
Brainfuck is an extremely simple, minimalist untyped esoteric programming language; plain in specification (consisting only of 8 commands) but difficult to program in (it is so called Turing tarpit). It works similarly to a pure Turing machine. In a way it is beautiful by its simplicity, writing brainfuck interpreter (or even a compiler) is almost trivial -- in fact the Brainfuck author's goal was to construct 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 .
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 pointerCharacters 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.
This is a very simple C implementation of Brainfuck interpreter:
#include <stdio.h>
const char program[] = ",[.-]"; // your program here
#define CELLS 30000
char tape[CELLS];
int main(void)
{
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++;
}
return 0;
}
TODO: comun implementation
Advanced Brainfuck implementations may include optimizations, for example things like >>><<> may be reduced to >> etc.
And here is a Brainfuck to C transpiler, written in C, which EVEN does the above simple optimization of grouping together additions, subtractions and shifts. It will allow you to compile Brainfuck to native executables. The code is possibly even simpler than the interpreter:
#include <stdio.h>
int main(void)
{
int c, cNext;
puts("#include <stdio.h>\nunsigned char m[1024];\n"
"char *c = m;\nint main(void) {");
#define NEXT { c = cNext; cNext = getchar(); }
NEXT NEXT
while (c != EOF)
{
switch (c)
{
case '>': case '<': case '+': case '-':
{
unsigned int n = 1;
while (cNext == c)
{
NEXT
n++;
}
printf(" %s %c= %u;\n",(c == '<' || c == '>') ? "c" : "*c",
(c == '>' || c == '+') ? '+' : '-',n);
break;
}
case '.': puts(" putchar(*c);"); break;
case ',': puts(" *c = getchar();"); break;
case '[': puts(" while (*c) {"); break;
case ']': puts(" }"); break;
default: break;
}
NEXT
}
puts("return 0; }");
return 0;
}
Here are some simple programs in brainfuck.
Print HI:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ . + .
Read two 0-9 numbers (as ASCII digits) and add them:
,>,[<+>-]<------------------------------------------------.
Brainfuck became an inspiration to a plethora of derivative languages (esolang wiki currently lists over 700) many of which pay homage to their ancestor by including the word fuck in the name. Oftentimes we see extensions adding new features or languages that just translate to Brainfuck, i.e. are defined in terms of Brainfuck. Some of notable Brainfuck derivatives include: Fuck (only has a single memory cell), Brainfork (adds multithreading with new command Y), Unary (program source code only uses one character, compiled to BF), Mierda (just replaces the commands with Spanish words), Brainfuck++, Agony etc.
{ There probably exist BF derivatives in this spirit, it's very natural, I didn't bother checking too much, here I just want to derive this from scratch myself, for educational purposes. ~drummyfish }
What if we want to actually write a more complex program in Brainfuck? How do we tame the beast and get out of the Turing tarpit? We may build a metalanguage on top of Brainfuck that will offer more convenient constructs and will compile to Brainfuck, and maybe we'll learn something about building and bootstrapping computing environments along the way :) We may do this e.g. with a simple system of preprocessing macros, i.e. we will create a language with more advanced commands that will be replaced by plain Brainfuck commands -- on the level of source code -- before it gets executed. This turns out to be a quite effective approach that enables us to create sort of a Forth-like language in which we may program quite complex things with the stack-based computing paradigm.
Hmmm okay, what name do we give the language? Let's call it Macrofucker. It will work like this:
:M<commands>;. : and ; are simply keywords separating the macro definition, M is the macro name, which we'll for simplicity sake limit to single uppercase letters only (so we won't be able to make more macros than there are letters), and <commands> are just commands that will be copy-pasted wherever the macro is used.
M defined (anywhere in the source code), we can use it by simply writing M. Optionally we may call it with numeric parameter as MX, where X is a decimal number. If no parameter is given, we consider it 0. Macro may be invoked even inside another macro.
$ that will make the next character be repeated the macro's argument number of times -- i.e. if the macro was called with let's argument 3, then $> will output >>>. This symbol can also be used in the same sense in front of macro invocation.For example consider the following piece of code:
:X[-]$+; >X10 >X11 >X12 >X13
We first define macro called X that serves for storing constants in cells. The macro first zeroes the cell ([-]) and then repeats the character + the argument number of times. Then we use the macro 4 times, with constants 10, 11, 12 and 13. We also shift right before each macro invocation so it's as if we're pushing the constants on the stack. This code will compile to:
>[-]++++++++++>[-]+++++++++++>[-]++++++++++++>[-]+++++++++++++
If we examine and run the code, we indeed find that we end up with the values 10, 11, 12 and 13 on the tape:
0 10 11 12 13
^
Implementing the preprocessor is about as simple as implementing Brainfuck itself: pretty easy. As soon as we have the preprocessor, we may start implementing a "library" of macros, i.e. we may expand Brainfuck by adding quite powerful commands -- the beauty of it is we'll be expanding the language in Macrofucker itself from now on, no more C code is required beyond writing the simple preprocessor. This is a very cool, minimalist approach of building complex things by adding simple but powerful extensions to very simple things, the kind of incremental programming approach that's masterfully applied in languages such as Forth and Lisp.
So here it is, the Macrofucker preprocessor in C, along with embedded code of the program it processes -- here we include simple library that even includes things such as division, modulus and printing and reading decimal values:
#include <stdio.h>
const char program[] =
// the library (WARNING: cells to the right may be changed):
":Z[-];" // zero: c[0] = 0
":L$<;" // left: c -= N
":R$>;" // right: c += N
":I$+;" // inc: c[0] += N
":D$-;" // dec: c[0] -= N
":XZ$+;" // const: c[0] = N
":N>Z+<[Z>-<]>[<$++>Z]<;" // not: c[0] = c[0] == 0 ? N + 1 : 0
":CZ>Z<<$<[-$>>+>+<$<<]$>>>[-<$<<+>>$>]<;" // copy: c[0] = c[-(N + 1)]
":M>C<Z>[-<$-->]<;" // minus: c[0] *= -(N + 1)
":F>Z<[->+<]<$<[->$>+<$<]$>>>[-<<$<+>>$>]<;" // flip: SWAP(c[0],c[-(N + 1)])
":A>C1[-<+>]<;" // add: c[0] += c[-1]
":S>C1[-<->]<;" // subtract: c[0] -= c[-1]
":T>C1>C1>Z<<-[->>A<<]>>[-L3+R3]L3;" // times: c[0] *= c[-1]
":EC1>C1[-<->]<N;" // equals: c[-2] == c[-1] ? 1 : 0
":GZ>C2>C2+<[->->CN[L3+R3Z]<<]<;" // greater: c[-1] > c[0] ? 1 : 0
":B>C1>C1<<Z>>>GN[L3+>>S>GN]<F<;" // by: c[1] = c[0] % c[-1]; c[0] = c[0] / c[-1]; c++
":P>X100>C1BF>X48A.L3X10>BF>X48A.<F>X48A.L4;" // print: print byte as decimal
":VX48>,SFX100T>X48>,SFX10TF<A>X48>,SF<AF2L3;" // value: reads decimal number of three digits
// the main program itself:
"Z>V>C[>C1BN[L4+R4Z]<<-]<<P>X10.X2>E[X112.X114.X105.X109.X101.X10.Z]"
;
void process(const char *c, int topLevel)
{
char f = *c; // macro name to search
unsigned int n = 0; // macro argument
if (!topLevel) // read the argument
{
c++;
while (*c >= '0' && *c <= '9')
{
n = 10 * n + *c - '0';
c++;
}
}
#define IS_MACRO(x) ((x) >= 'A' && (x) <= 'Z')
c = program;
while (*c) // search for the macro definition
{
if (topLevel || (c[0] == ':' && c[1] == f))
{
c += topLevel ? 0 : 2; // skip the beginning macro chars
while (*c && *c != ';')
{
if (*c == ':')
while ((*++c) != ';'); // skip macro definitions
else if (*c == '+' || *c == '-' || *c == '<' || *c == '>' ||
*c == '[' || *c == ']' || *c == '.' || *c == ',')
putchar(*c); // normal BF commands
else if (IS_MACRO(*c))
process(c,0); // macro
else if (*c == '$')
{
c++;
for (unsigned int i = 0; i < n; ++i)
IS_MACRO(*c) ? process(c,0) : putchar(*c);
}
c++;
}
return;
}
c++;
}
}
int main(int argc, char **argv)
{
process(program,1);
putchar(0); // allows separating program on stdin from program input
//puts("013"); // program input may go here
return 0;
}
The main program we have here is the example program from the algorithm article: it reads a number, prints the number of its divisors and says if the number is prime. Code of the Brainfuck program will be simply printed out on standard output and it can then be run using our Brainfuck interpreter above. Unlike "hello world" this is already a pretty cool problem we've solved with Brainfuck, and we didn't even need that much code to make it happen. Improving this further could allow us to make a completely usable (though, truth be said, probably slow) language. Isn't this just beautiful? Yes, it is :)
So just for completeness, here is a Macrofucker program that prints out the first 10 Fibonacci numbers:
:Z[-]; zero the cell :L$<; go left by n :R$>; go right by n :XZ$+; store constant n :N>Z+<[Z>-<]>[<$++>Z]<; not :CZ>Z<<$<[-$>>+>+<$<<]$>>>[-<$<<+>>$>]<; copy :F>Z<[->+<]<$<[->$>+<$<]$>>>[-<<$<+>>$>]<; flip :A>C1[-<+>]<; add :S>C1[-<->]<; subtract :GZ>C2>C2+<[->->CN[L3+R3Z]<<]<; greater :B>C1>C1<<Z>>>GN[L3+>>S>GN]<F<; divide :P>X100>C1BF>X48A.L3X10>BF>X48A.<F>X48A.L4; print main program >X10 loop counter >X0 first number >X1 second number << [- loop R3 C1 A copy and add P > X10 . print number and newline < F < F << go back and shift numbers ]
which translates to:
>[-]++++++++++>[-]>[-]+<<[->>>[-]>[-]<<<[->>+>+<<<]>>>[-<<< +>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<>[-]++++++ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+<<<]>> >[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<< [->>+>+<<<]>>>[-<<<+>>>]<<<[-]>>>[-]>[-]>[-]<<<<[->>>+>+<<< <]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>> ]<+<[->->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[- ]]<[<<<+>>>[-]]<<]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]>[-]< <<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-]>[-]>[-]<<<<[->>>+>+< <<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>> >>]<+<[->->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+> [-]]<[<<<+>>>[-]]<<]<>[-]+<[[-]>-<]>[<+>[-]]<]<>[-]<[->+<]< [->+<]>>[-<<+>>]<<>[-]<[->+<]<[->+<]>>[-<<+>>]<>[-]++++++++ ++++++++++++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+< <<]>>>[-<<<+>>>]<[-<+>]<.<<<[-]++++++++++>>[-]>[-]<<<[->>+> +<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<<<[- ]>>>[-]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<< <<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->->[-]>[-]<<[->+>+<<]>> [-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[-] >-<]>[<+>[-]]<[<<<+>>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[- <->]<>[-]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-] <<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->->[-]>[-]<<[->+>+<<] >>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[ -]>-<]>[<+>[-]]<]<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]<[->+<] <[->+<]>>[-<<+>>]<>[-]+++++++++++++++++++++++++++++++++++++ +++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<.<>[- ]<[->+<]<[->+<]>>[-<<+>>]<>[-]+++++++++++++++++++++++++++++ +++++++++++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+ >]<.<<<<>[-]++++++++++.<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]< [->+<]<[->+<]>>[-<<+>>]<<<]
which outputs:
001 001 002 003 005 008 013 021 034 055
{ We have a C tutorial! ~drummyfish }
C is an old low level structured statically typed imperative compiled programming language, it is very fast, efficient and currently possibly the most commonly used language by many minimalist programmers including less retarded software. Though by very strict standards it would still be considered bloated, compared to any mainstream modern language it is very bullshitless, KISS, very well optimized, culturally established and stable, so it is also the go-to language of the suckless community as well as most true experts, for example the Linux and OpenBSD developers (UPDATE: after 2025 it no longer holds that Linux would be written by experts), owing to a good, relatively simple design, uncontested performance, wide support, great number of compilers, high level of control and a status of firmly tested and established language. C doesn't belong to the class of most minimal languages like Forth, Lisp and Brainfuck, but it is among the most minimalist "traditional" kind of languages. C is perhaps the most important language in history; it influenced, to smaller or bigger degree, basically all of the widely used languages today such as C++, Java, JavaScript etc., however it is not a relic of the past, it is still actively used -- in the area of low level programming C is probably still the number one unsurpassed language. C is by no means perfect or extremely mathematically elegant, but it is currently one of the best practical choice of a programming language. Though C is almost always compiled, C interpreters can be found too.
Notable software written in C includes Unix, Doom, Duke Nukem 3D, Linux, OpenBSD, Anarch, dwm, git, Vim, Quake, ffmpeg, Wolfenstein 3D, Licar, SAF, SQLite and more.
{ See https://wiki.bibanon.org/The_Perpetual_Playthings. Also look up The Ten Commandments for C Programmers by Henry Spencer. Also the Write in C song (parody of Let it Be). ~drummyfish }
It is usually not considered an easy language to learn because of its low level nature and amount of control (fuck up opportunities) it gives: it requires good understanding of how a computer works on the lower level and doesn't prevent the programmer from shooting himself in the foot. Programmer is given full control (and therefore "responsibility"). There are things considered "tricky" which one must be aware of, such as undefined behavior of certain operators or manual memory management. This is what can discourage a lot of modern "coding monkeys" from choosing C, but it's also what inevitably allows such great performance -- undefined behavior allows the compiler to choose the most efficient implementation. On the other hand, C as a language is pretty simple without modern bullshit concepts such as OOP, it is not as much hard to learn but rather hard to master, as any other true art. In any case you have to learn C even if you don't plan to program in it regularly, it's the most important language in history and lingua franca of programming, you will meet C in many places and have to at least understand it: programmers very often use C instead of pseudocode to explain algorithms, C is used for optimizing critical parts even in non-C projects, many languages compile to C, it is just all around and you have to understand it like you have to understand English.
Some of the typical traits of C include plentiful (over)utilization of preprocessor (macros, the underlying C code is infamously littered with "#ifdefs" all over the place which modify the code just before compiling -- this is mostly used for compile-time configuration and/or achieving better performance and/or for portability), pointers (direct access to memory, used e.g. for memory allocation, this is infamously related to "shooting oneself in the foot", e.g. by getting memory leaks) and a lot of undefined behavior (many things are purposefully left undefined in C to allow compilers to generate greatly efficient code, but this sometimes lead to weird bugs or a program working on one machine but not another, so C requires some knowledge of its specification). Also a bit infamous one may encounter complicated type declarations like void (*float(int,void (*n)(int)))(int), these are frequently a subject of jokes ("look, C is simple").
Unlike many "modern" languages, C by itself doesn't offer too much advanced and fancy functionality such as displaying graphics, working with network, getting raw keyboard state and so on -- the base language doesn't even have any input/output, it's a pure processor of values in memory. The standard library offers things like basic I/O with standard input/output streams, handling files on the disk, manipulating strings, handling time, evaluating mathematical functions and other things, but for anything more advanced you will need an external library like SDL or those defined by Posix.
C is said to be a "portable assembly" not only because it is quite low level and almost on par with assembly in performance, but also because many languages just choose to compile to C rather than to compile to assembly. Though C is structured (has control structures such as branches and loops) and can be used in a relatively high level manner, it is also possible to write assembly-like code that operates directly with bytes in memory through pointers without many safety mechanisms, so C is often used for writing things like hardware drivers. On the other hand some restrain from likening C to assembly because C compilers still perform many transformations of the code and what you write is not necessarily always what you get.
Mainstream consensus acknowledges that C is among the best languages for writing low level code and code that requires performance, such as operating systems, drivers or games. Even scientific libraries with normie-language interfaces -- e.g. various machine learning Python libraries -- usually have the performance critical core written in C. Normies will tell you that for things outside this scope C is not a good language, with which we disagree -- we recommend using C for basically everything that's supposed to last, i.e. if you want to write a good dynamic website, you should probably write it in C.
C is NOT a subset of C++. This is proven for example by the simple example of a C program that uses the word class as a name for a variable -- in C++ this cannot be done. Sometimes the differences between C and C++ are bigger, for example in semantics, and may cause trouble to those who don't know about them. It is true that many C programs will run as C++ just fine, but not nearly all, and some C programs that run as C++ will have different behavior. We have to always be aware of this.
Is C low or high level? This depends on the context. Firstly back in the day when most computers were programmed in assembly, C was seen as high level, simply because it offered the highest level of abstraction at the time, while nowadays with languages like Python and JavaScript around people see C as very low level by comparison -- so it really depends on if you talk about C in context of "old" or "modern" programming and which languages you compare it to. Secondly it also depends on HOW you program in C -- you may choose to imitate assembly programming in C a lot, avoid using libraries, touch hardware directly, avoid using complex features and creating your own abstractions -- here you are really doing low level programming. On the other hand you can emulate the "modern" high-level style programming in C too, you can even mimic OOP and make it kind of "C++ with different syntax", you may use libraries that allow you to easily work with strings, heavy macros that pimp the language to some spectacular abomination, you may write your own garbage collector etc. -- here you are basically doing high level programming in C.
Fun: main[-1u]={1}; is a C compiler bomb :) it's a short program that usually makes the compiler produce a huge binary.
Let's write a simple program called divisor tree -- this program will be interactively reading positive numbers (smaller than 1000) from the user and for each one it will print the binary tree of the numbers divisors so that if a number has divisors, the ones that are closest to each other will be its children. If invalid input is given, the program ends. The tree will be written in format (L N R) where N is the number of the tree node, L is its the node's left subtree and R is the right subtree. This problem is made so that it will showcase most of the basic features of a programming language (like control structures, function definition, recursion, input/output etc.). Let's from now on consider this our standardized program for showcasing programming languages.
Here is the program written in C99 (let this also serve as a reference implementation of the program):
#include <stdio.h> // include standard I/O library
// recursive function, prints divisor tree of x
void printDivisorTree(unsigned int x)
{
int a = -1, b = -1;
for (int i = 2; i <= x / 2; ++i) // find two closest divisors
if (x % i == 0)
{
a = i;
b = x / i;
if (b <= a)
break;
}
putchar('(');
if (a > 1)
{
printDivisorTree(a);
printf(" %d ",x);
printDivisorTree(b);
}
else
printf("%d",x);
putchar(')');
}
int main(void)
{
while (1) // main loop, read numbers from the user
{
unsigned int number;
printf("enter a number: ");
if (scanf("%u",&number) == 1 && number < 1000)
{
printDivisorTree(number);
putchar('\n');
}
else
break;
}
return 0;
}
Run of this program may look for example like this:
enter a number: 32 ((((2) 4 (2)) 8 (2)) 32 ((2) 4 (2))) enter a number: 256 ((((2) 4 (2)) 16 ((2) 4 (2))) 256 (((2) 4 (2)) 16 ((2) 4 (2)))) enter a number: 7 (7) enter a number: 0 (0) enter a number: 15 ((5) 15 (3)) enter a number: quit
C was developed in 1972 at Bell Labs alongside the Unix operating system by Dennis Ritchie and Brian Kerninghan, as a successor to the B language (portable language with recursion) written by Denis Ritchie and Ken Thompson, which was in turn inspired by the the ALGOL language (code blocks, lexical scope, ...). C was for a while called NB for "new B". C was intimately interconnected with Unix and its hacker culture, both projects would continue to be developed together, influencing each other. In 1973 Unix was rewritten in C. In 1978 Keninghan and Ritchie published a book called The C Programming Language, known as K&R, which became something akin to the C specification. In March 1987 Richard Stallman along with others released the first version of GNU C compiler -- the official compiler of the GNU project and the compiler that would go on to become one of the most widely used. In 1989, the ANSI C standard, also known as C89, was released by the American ANSI -- this is a very well supported and overall good standard. The same standard was also adopted a year later by the international ISO, so C90 refers to the same language. In 1999 ISO issues a new standard that's known as C99, still a very good standard embraced by LRS. Later in 2011 and 2017 the standard was revised again to C11 and C17, which are however no longer considered good.
C is not a single language, there have been a few standards over the years since its inception in 1970s. The standard defines two major parts: the base language and standard library. Notable standards and versions are:
// comments, stdint library (fixed-width integer types), float and long long type, variable length stack-allocated arrays, variadic macros and declaration of variables "anywhere" (not just at function start).
Quite nice online reference to all the different standards (including C++) is available at https://en.cppreference.com/w/c/99.
LRS should use C99 or C89 as the newer versions are considered bloat and don't have such great support in compilers, making them less portable and therefore less free.
The standards of C99 and older are considered pretty future-proof and using them will help your program be future-proof as well. This is to a high degree due to C having been established and tested better than any other language; it is one of the oldest languages and a majority of the most essential software is written in C, C compiler is one of the very first things a new hardware platform needs to implement, so C compilers will always be around, at least for historical reasons. C has also been very well designed in a relatively minimal fashion, before the advent of modern feature-creep and and bullshit such as OOP which cripples almost all "modern" languages.
C is extreme well established, standardized and implemented so there is a great number of C compilers around. Let us list only some of the more notable ones.
Besides the pure C language the C standard specifies a set of libraries that have to come with a standard-compliant C implementation -- so called standard library. This includes e.g. the stdio library for performing standard input/output (reading/writing to/from screen/files) or the math library for mathematical functions. It is usually relatively okay to use these libraries as they are required by the standard to exist so the dependency they create is not as dangerous, however many C implementations aren't completely compliant with the standard and may come without the standard library. Also many stdlib implementations suck or you just can't be sure what the implementation will prefer (size? speed?) etc. So for sake of portability it is best if you can avoid using standard library.
The standard library (libc) is a subject of live debate because while its interface and behavior are given by the C standard, its implementation is a matter of each compiler; since the standard library is so commonly used, we should take great care in assuring it's extremely well written, however we ALWAYS have to choose our priorities and make tradeoffs, there just mathematically CANNOT be an ultimate implementation that will be all extremely fast and extremely memory efficient and extremely portable and extremely small. So choosing your C environment usually comprises of choosing the C compiler and the stdlib implementation. As you probably guessed, the popular implementations (glibc et al) are bloat and also often just shit. Better alternatives thankfully exist, such as:
Firstly let's sum up some of the reasons why C is so good:
Now let's admit that nothing is perfect, not even C; it was one of the first relatively higher level languages and even though it has showed to have been designed extremely well, some things didn't turn out that well. We still prefer C as one of the best choices, but it's good to be aware of its downsides and smaller issues, if only for the sake of one day designing a better language. Please bear in mind all here are just suggestions, they may of course be a subject to counter arguments and further discussion. Here are some of the bad things about the language:
struct, except for an array. This makes it awkward for example when implementing vectors which would best be made as arrays but you want functions to return them, so you are forced to ugly hacks like wrapping them inside a struct just for this.
myvalue /*myptr), also multiplication and pointer dereference use the same symbol * while both operation can be used with a pointer -- that may create confusion. Also a case label with variables inside it HAS TO be enclosed in curly brackets but other ones don't, data type names may consist of multiple tokens (long long int etc.), many preprocessor commands need to be on separate lines (makes some one liners impossible), also it's pretty weird that the condition after if has to be in brackets etc., it could all be designed better. Keywords also might be better being single chars, like ? instead of if etc. (see comun). A shorter source code that doesn't try to imitate English would be probably better.
This is a quick overview, for a more in depth tutorial see C tutorial.
A simple program in C that writes "welcome to C" looks like this:
#include <stdio.h> // standard I/O library
int main(void)
{
// this is the main program
puts("welcome to C");
return 0; // end with success
}
You can simply paste this code into a file which you name let's say program.c, then you can compile the program from command line like this:
`cc -o program program.c
Then if you run the program from command line (./program on Unix like systems) you should see the message.
Here is a quick reference cheatsheet of some of the important things in C, also a possible overview of the language.
data types (just some):
| data type | values (size) | printf | notes |
|---|---|---|---|
int (signed int, ...) | integer, at least -32767 to 32767 (16 bit), often more | %d | native integer, fast (prefer for speed) |
unsigned int | integer, non-negative, at least 0 to 65535, often more | %u | same as int but no negative values |
signed char | integer, at least -127 to 127, mostly -128 to 127 | %c, %hhi | char forced to be signed |
unsigned char | integer, at least 0 to 255 (almost always the case) | %c, %hhu | smallest memory chunk, byte |
char | integer, at least 256 values | %c | signed or unsigned, used for string characters |
short | integer, at least -32767 to 32767 (16 bit) | %hd | like int but supposed to be smaller |
unsigned short | integer, non-negative, at least 0 to 65535 | %hu | like short but unsigned |
long | integer, at least -2147483647 to 2147483647 (32 bit) | %ld | for big signed values |
unsigned long | integer, at least 0 to 4294967295 (32 bit) | %lu | for big unsigned values |
long long | integer, at least some -9 * 10^18 to 9 * 10^18 (64 bit) | %lld | for very big signed values |
unsigned long long | integer, at least 0 to 18446744073709551615 (64 bit) | %llu | for very big unsigned values |
float | floating point, some -3 * 10^38 to 3 * 10^38 | %f | float, tricky, bloat, can be slow, avoid |
double | floating point, some -1 * 10^308 to 10^308 | %lf | like float but bigger |
T [N] | array of N values of type T | array, if T is char then string | |
T * | memory address | %p | pointer to type T, (if char then string) |
uint8_t | 0 to 255 (8 bit) | PRIu8 | exact width, two's compl., must include <stdint.h> |
int8_t | -128 to 127 (8 bit) | PRId8 | like uint8_t but signed |
uint16_t | 0 to 65535 (16 bit) | PRIu16 | like uint8_t but 16 bit |
int16_t | -32768 to 32767 (16 bit) | PRId16 | like uint16_t but signed |
uint32_t | -2147483648 to 2147483647 (32 bit) | PRIu32 | like uint8_t but 32 bit |
int32_t | 0 to 4294967295 (32 bit) | PRId32 | like uint32_t but signed |
int_least8_t | at least -128 to 127 | PRIdLEAST8 | signed integer with at least 8 bits, <stdint.h> |
int_fast8_t | at least -128 to 127 | PRIdFAST8 | fast signed int. with at least 8 bits, <stdint.h> |
| struct | structured data type |
There is no bool (true, false), use any integer type, 0 is false, everything else is true (there may be some bool type in the stdlib, don't use that). A string is just array of chars, it has to end with value 0 (NOT ASCII character for "0" but literally integer value 0)!
main program structure:
#include <stdio.h>
int main(void)
{
// code here
return 0;
}
branching aka if-then-else:
if (CONDITION)
{
// do something here
}
else // optional
{
// do something else here
}
for loop (repeat given number of times):
for (int i = 0; i < MAX; ++i)
{
// do something here, you can use i
}
while loop (repeat while CONDITION holds):
while (CONDITION)
{
// do something here
}
do while loop (same as while but CONDITION at the end), not used that much:
do
{
// do something here
} while (CONDITION);
function definition:
RETURN_TYPE myFunction (TYPE1 param1, TYPE2 param2, ...)
{ // return type can be void
// do something here
}
compilation (you can replace gcc with another compiler):
gcc myprogram.c && ./a.out.
gcc -std=c99 -Wall -Wextra -pedantic -O3 -o myprogram myprogram.c.To link a library use -llibrary, e.g. -lm (when using <math.h>), -lSDL2 etc.
The following are some symbols (functions, macros, ...) from the standard library:
| symbol | library | description | example |
|---|---|---|---|
| putchar(c) | stdio.h | Writes a single character to output. | putchar('a'); |
| getchar() | stdio.h | Reads a single character from input. | int inputChar = getchar(); |
| puts(s) | stdio.h | Writes string to output (adds newline at the end). | puts("hello"); |
| printf(s, a, b, ...) | stdio.h | Complex print func., allow printing numbers, their formatting etc. | printf("value is %d\n",var); |
| scanf(s, a, b, ...) | stdio.h | Complex reading func., allows reading numbers etc. | scanf("%d",&var); |
| fopen(f,mode) | stdio.h | Opens file with given name in specific mode, returns pointer. | FILE *myFile = fopen("myfile.txt","r"); |
| fclose(f) | stdio.h | Closes previously opened file. | fclose(myFile); |
| fputc(c,f) | stdio.h | Writes a single character to file. | fputc('a',myFile); |
| fgetc(f) | stdio.h | Reads a single character from file. | int fileChar = fgetc(myFile); |
| fputs(s,f) | stdio.h | Writes string to file (without newline at end). | fputs("hello",myFile); |
| fprintf(s, a, b, ...) | stdio.h | Like printf but outputs to a file. | fprintf(myFile,"value is %d\n",var); |
| fscanf(f, s, a, b, ...) | stdio.h | Like scanf but reads from a file. | fscanf(myFile,"%d",&var); |
| fread(data,size,n,f) | stdio.h | Reads n elems to data from file, returns no. of elems read. | fread(myArray,sizeof(item),1,myFile); |
| fwrite(data,size,n,f) | stdio.h | Writes n elems from data to file, returns no. of elems writ. | fwrite(myArray,sizeof(item),1,myFile); |
| EOF | stdio.h | End of file value. | int c = getchar(); if (c == EOF) break; |
| rand() | stdlib.h | Returns pseudorandom number. | char randomLetter = 'a' + rand() % 26; |
| srand(n) | stdlib.h | Seeds pseudorandom number generator. | srand(time(NULL)); |
| NULL | stdlib.h, ... | Value assigned to pointers that point "nowhere". | int *myPointer = NULL; |
| malloc(size) | stdlib.h | Dynamically allocates memory, returns pointer to it (or NULL). | int *myArr = malloc(sizeof(int) * 10); |
| realloc(mem,size) | stdlib.h | Resizes dynamically allocates memory, returns pointer (or NULL). | myArr = realloc(myArr,sizeof(int) * 20); |
| free(mem) | stdlib.h | Frees dynamically allocated memory. | free(myArr); |
| atof(str) | stdlib.h | Converts string to floating point number. | double val = atof(answerStr); |
| atoi(str) | stdlib.h | Converts string to integer number. | int val = atof(answerStr); |
| EXIT_SUCCESS | stdlib.h | Value the program should return on successful exit. | return EXIT_SUCCESS; |
| EXIT_FAILURE | stdlib.h | Value the program should return on exit with error. | return EXIT_FAILURE; |
| sin(x) | math.h | Returns sine of angle in RADIANS. | float angleSin = sin(angle); |
| cos(x) | math.h | Like sin but returns cosine. | float angleCos = cos(angle); |
| tan(x) | math.h | Returns tangent of angle in RADIANS. | float angleTan = tan(angle); |
| asin(x) | math.h | Returns arcus sine of angle, in RADIANS. | float angle = asin(angleSine); |
| ceil(x) | math.h | Rounds a floating point value up. | double x = ceil(y); |
| floor(x) | math.h | Rounds a floating point value down. | double x = floor(y); |
| fmod(a,b) | math.h | Returns floating point reminded after division. | double rem = modf(x,3.5); |
| isnan(x) | math.h | Checks if given float value is NaN. | if (!isnan(x)) |
| NAN | math.h | Float quiet NaN (not a number) value, don't compare! | if (y == 0) return NAN; |
| log(x) | math.h | Computes natural logarithm (base e). | double x = log(y); |
| log10(x) | math.h | Computes decadic logarithm (base 10). | double x = log10(y); |
| log2(x) | math.h | Computes binary logarithm (base 2). | double x = log2(y); |
| exp(x) | math.h | Computes exponential function (e^x). | double x = exp(y); |
| sqrt(x) | math.h | Computes floating point square root. | double dist = sqrt(dx * dx + dy * dy); |
| pow(a,b) | math.h | Power, raises a to b (both floating point). | double cubeRoot = pow(var,1.0/3.0); |
| abs(x) | math.h | Computes absolute value. | double varAbs = abs(var); |
| INT_MAX | limits.h | Maximum value that can be stored in int type. | printf("int max: %d\n",INT_MAX); |
| memset(mem,val,size) | string.h | Fills block of memory with given values. | memset(myArr,0,sizeof(myArr)); |
| memcpy(dest,src,size) | string.h | Copies bytes of memory from one place to another, returns dest. | memcpy(destArr,srcArr,sizeof(srcArr); |
| strcpy(dest,src) | string.h | Copies string (zero terminated) to dest, unsafe. | char myStr[16]; strcpy(myStr,"hello"); |
| strncpy(dest,src,n) | string.h | Like strcpy but limits max number of bytes to copy, safer. | strncpy(destStr,srcStr,sizeof(destStr)); |
| strcmp(s1,s2) | string.h | Compares two strings, returns 0 if equal. | if (!strcmp(str1,"something")) |
| strlen(str) | string.h | Returns length of given string. | int l = strlen(myStr); |
| strstr(str,substr) | string.h | Finds substring in string, returns pointer to it (or NULL). | if (strstr(cmdStr,"quit") != NULL) |
| time(t) | time.h | Stores calendar time (often Unix t.) in t (can be NULL), returns it. | printf("tstamp: %d\n",(int) time(NULL)); |
| clock() | time.h | Returns approx. CPU cycle count since program start. | printf("CPU ticks: %d\n",(int) clock()); |
| CLOCKS_PER_SEC | time.h | Number of CPU ticks per second. | int sElapsed = clock() / CLOCKS_PER_SEC; |
{ Constant work in progress, mostly done but may still have some bugs. ~drummyfish }
This is a relatively quick and hopefully digestible C tutorial.
You should probably have at least some basic awareness of essential programming concepts before reading this (what's a programming language, source code, command line etc.). If you're as far as already somewhat knowing another language, this should be pretty easy to understand.
This tutorial focuses on teaching pure C, i.e. mostly just command line text-only programs. There is a small bonus that shows some very basics of doing graphics programming at the end, but bear in mind it's inevitable to learn step by step, as much as you want to start programming graphical games, first and foremost you HAVE TO learn the language itself well. Don't rush it. Trust this advice, it is sincere.
If you do two chapters a day (should take like half and hour), in a week you'll know some basic C.
Potentially supplemental articles to this tutorial are:
C is
If by chance you're already familiar with languages like Python or JavaScript, you may be shocked that C doesn't come with its own package manager, debugger or build system, it doesn't have modules, generics, garabage collection, OOP, hashmaps, dynamic lists, type inference and similar "modern" features. When you truly get into C, you'll find it's a good thing.
Programming in C works like this:
So, for typing source code you'll need a text editor; any plain text editor will do but you should use some that can highlight C syntax -- this helps very much when programming and is practically a necessity. Ideal editor is vim but it's a bit difficult to learn so you can use something as simple as Gedit or Geany. We do NOT recommend using large programming IDEs such as "VS Code" and whatnot. You definitely can NOT use an advanced document editor that edits rich text such as LibreOffice or that shit from Micro$oft, this won't work because it's not plain text.
Next you'll need a C compiler, the program that will turn your source code into a runnable program. We'll use the most commonly used one called gcc (you can try different ones such as clang or tcc if you want). If you're on a Unix-like system such as GNU/Linux (which you probably should), gcc is probably already installed. Open up a terminal and write gcc to see if it's installed -- if not, then install it (e.g. with sudo apt install build-essential if you're on a Debian-based system).
If you're super lazy (as programmers often are), you may appreciate the existence of online web C compilers that conveniently work in a web browser (search for "online C compiler" or something). These may serve for quick experimentation but, as could be expected, browser tools won't replace the real deal, there are limitations (e.g. not being able to install libraries and so on), and you should definitely know how to compile programs yourself.
And one last note: there are multiple standards of C. Here we will be covering C99, but this likely doesn't have to bother you at this point. Let's proceed to some real action now.
Let's quickly try to compile a tiny program to test everything and see how everything works in practice.
Open your text editor and paste this code:
/* simple C program! */
#include <stdio.h> // include IO library
int main(void)
{
puts("It works.");
return 0;
}
Save this file and name it program.c. Then open a terminal emulator (or an equivalent command line interface), locate yourself into the directory where you saved the file (e.g. cd somedirectory) and compile the program with the following command:
gcc -o program program.c
The program should compile and the executable program should appear in the directory. You can run it with
./program
And you should see
It works.
written in the command line.
Now let's see what the source code means:
/* simple C program! */ is so called block comment, it does nothing, it's here only for the humans that will read the source code. Such comments can be almost anywhere in the code. The comment starts at /* and ends with */.
// include IO library is another comment, but this is a line comment, it starts with // and ends with the end of line.
#include <stdio.h> tells the compiler we want to include a library named stdio (the weird syntax will be explained in the future). This is a standard library with input output functions, we need it to be able to use the function puts later on. We can include more libraries if we want to. These includes are almost always at the very top of the source code.
int main(void) is the start of the main program. What exactly this means will be explained later, for now just remember there has to be this function named main in basically every program -- inside it there are commands that will be executed when the program is run. Note that the curly brackets that follow ({ and }) denote the block of code that belongs to this function, so we need to write our commands between these brackets.
puts("It works."); is a "command" for printing text strings to the command line (it's a command from the stdio library included above). Why exactly this is written like this will be explained later, but for now notice the following. The command starts with its name (puts, for put string), then there are left and right brackets (( and )) between which there are arguments to the command, in our case there is one, the text string "It works.". Text strings have to be put between quotes ("), otherwise the compiler would think the words are other commands (the quotes are not part of the string itself, they won't be printed out). The command is terminated by ; -- all "normal" commands in C have to end with a semicolon.
return 0; is another "command", it basically tells the operating system that everything was terminated successfully (0 is a code for success). This command is an exception in that it doesn't have to have brackets (( and )). This doesn't have to bother us too much now, let's just remember this will always be the last command in our program.Also notice how the source code is formatted, e.g. the indentation of code within the { and } brackets. White characters (spaces, new lines, tabs) are ignored by the compiler so we can theoretically write our program on a single line, but that would be unreadable. We use indentation, spaces and empty lines to format the code to be well readable.
To sum up let's see a general structure of a typical C program. You can just copy paste this for any new program and then just start writing commands in the main function.
#include <stdio.h> // include the I/O library
// more libraries can be included here
int main(void)
{
// write commands here
return 0; // always the last command
}
Programming is a lot like mathematics, we compute equations and transform numeric values into other values -- in the end everything is just a number. You probably remember that in mathematics we use variables such as x or y to denote numeric values that can change (hence variables). In programming we also use variables that are likewise names that stand for values that can change -- more specifically variable is a place in memory which has a name (and in this place there will be stored a value that can change over time).
We can create variables named x, y, myVariable or score and then store specific values (for now let's only consider numbers) into them. We can read from and write to these variables at any time. These variables physically reside in RAM, but we don't really care where exactly (at which address) they are located -- this is similar to houses for example, in common talk we normally say something like John's house or the pet store instead of house with address 3225.
Variable names can't start with a digit (and they can't be any of the keywords reserved by C). By convention they also shouldn't be all uppercase or start with uppercase (these are normally used for other things). Frequently used conventions for naming variable are these: myVariable or my_variable (pick one style, don't mix them).
In C as in other languages each variable has a certain data type; that is each variable has associated an information of what kind of data is stored in it. This can be e.g. a whole number, fraction, a text character, text string etc. Data types are a more complex topic that will be discussed later, for now we'll start with the most basic one, the integer type, in C called int. An int variable can store whole numbers in the range of at least -32768 to 32767 (but usually much more).
Let's see an example.
#include <stdio.h>
int main(void)
{
int myVariable;
myVariable = 5;
printf("%d\n",myVariable);
myVariable = 8;
printf("%d\n",myVariable);
}
int myVariable; is so called variable declaration, it tells the compiler we are creating a new variable with the name myVariable and data type int. Variables can be created almost anywhere in the code (even outside the main function) but that's a topic for later.
myVariable = 5; is so called variable assignment, it stores a value 5 into variable named myVariable. IMPORTANT NOTE: the = does NOT signify mathematical equality but an assignment (equality in C is written as ==); when compiler encounters =, it simply takes the value on the right of it and writes it to the variable on the left side of it. Sometimes people confuse assignment with an equation that the compiler solves -- this is NOT the case, assignment is much more simple, it simply writes a value into variable. So x = x + 1; is a valid command even though mathematically it would be an equation without a solution.
printf("%d\n",myVariable); prints out the value currently stored in myVariable. Don't get scared by this complicated command, it will be explained later (once we learn about pointers). For now only know this prints the variable content.
myVariable = 8; assigns a new value to myVariable, overwriting the old.
printf("%d\n",myVariable); again prints the value in myVariable.After compiling and running of the program you should see:
5 8
Last thing to learn is arithmetic operators. They're just normal math operators such as +, - and /. You can use these along with brackets (( and )) to create expressions. Expressions can contain variables and can themselves be used in many places where variables can be used (but not everywhere, e.g. on the left side of variable assignment, that would make no sense). E.g.:
#include <stdio.h>
int main(void)
{
int heightCm = 175;
int weightKg = 75;
int bmi = (weightKg * 10000) / (heightCm * heightCm);
printf("%d\n",bmi);
}
calculates and prints your BMI (body mass index).
Let's quickly mention how you can read and write values in C so that you can begin to experiment with your own small programs. You don't have to understand the following syntax as of yet, it will be explained later, now simply copy-paste the commands:
puts("hello");: Prints a text string with newline.
printf("hello");: Same as above but without newline.
printf("%d\n",x);: Prints the value of variable x with newline.
printf("%d ");: Same as above but without a newline.
scanf("%d",&x);: Read a number from input to the variable x. Note there has to be & in front of x.When creating algorithms, it's not enough to just write linear sequences of commands. Two things (called control structures) are very important to have in addition:
Let's start with branches. In C the command for a branch is if. E.g.:
if (x > 10)
puts("X is greater than 10.");
The syntax is given, we start with if, then brackets (( and )) follow inside which there is a condition, then a command or a block of multiple commands (inside { and }) follow. If the condition in brackets holds, the command (or block of commands) gets executed, otherwise it is skipped.
Optionally there may be an else branch which is gets executed only if the condition does NOT hold. It is denoted with the else keyword which is again followed by a command or a block of multiple commands. Branching may also be nested, i.e. branches may be inside other branches. For example:
if (x > 10)
puts("X is greater than 10.");
else
{
puts("X is not greater than 10.");
if (x < 5)
puts("And it is also smaller than 5.");
}
So if x is equal e.g. 3, the output will be:
X is not greater than 10. And it is also smaller than 5.
About conditions in C: a condition is just an expression (variables/functions along with arithmetic operators). The expression is evaluated (computed) and the number that is obtained is interpreted as true or false like this: in C 0 (zero) means false, 1 (and everything else) means true. Even comparison operators like < and > are technically arithmetic, they compare numbers and yield either 1 or 0. Some operators commonly used in conditions are:
== (equals): yields 1 if the operands are equal, otherwise 0.
!= (not equal): yields 1 if the operands are NOT equal, otherwise 0.
< (less than): yields 1 if the first operand is smaller than the second, otherwise 0.
<=: yields 1 if the first operand is smaller or equal to the second, otherwise 0.
&& (logical AND): yields 1 if both operands are non-0, otherwise 0.
|| (logical OR): yields 1 if at least one operand is non-0, otherwise 0.
! (logical NOT): yields 1 if the operand is 0, otherwise 0.E.g. an if statement starting as if (x == 5 || x == 10) will be true if x is either 5 or 10.
Next we have loops. There are multiple kinds of loops even though in theory it is enough to only have one kind of loop (there are multiple types out of convenience). The loops in C are:
The while loop is used when we want to repeat something without knowing in advance how many times we'll repeat it (e.g. searching a word in text). It starts with the while keyword, is followed by brackets with a condition inside (same as with branches) and finally a command or a block of commands to be looped. For instance:
while (x > y) // as long as x is greater than y
{
printf("%d %d\n",x,y); // prints x and y
x = x - 1; // decrease x by 1
y = y * 2; // double y
}
puts("The loop ended.");
If x and y were to be equal 100 and 20 (respectively) before the loop is encountered, the output would be:
100 20 99 40 98 60 97 80 The loop ended.
The for loop is executed a fixed number of time, i.e. we use it when we know in advance how many time we want to repeat our commands. The syntax is a bit more complicated: it starts with the keywords for, then brackets (( and )) follow and then the command or a block of commands to be looped. The inside of the brackets consists of an initialization, condition and action separated by semicolon (;) -- don't worry, it is enough to just remember the structure. A for loop may look like this:
puts("Counting until 5...");
for (int i = 0; i < 5; ++i)
printf("%d\n",i); // prints i
`int i = 0 creates a new temporary variable named i (name normally used by convention) which is used as a **counter**, i.e. this variable starts at 0 and increases with each iteration (cycle), and it can be used inside the loop body (the repeated commands). i < 5 says the loop continues to repeat as long as i is smaller than 5 and ++i says that i is to be increased by 1 after each iteration (++i is basically just a shorthand for i = i + 1). The above code outputs:
Counting until 5... 0 1 2 3 4
IMPORTANT NOTE: in programming we count from 0, not from 1 (this is convenient e.g. in regards to pointers). So if we count to 5, we get 0, 1, 2, 3, 4. This is why i starts with value 0 and the end condition is i < 5 (not i <= 5).
Generally if we want to repeat the for loop N times, the format is for (int i = 0; i < N; ++i).
Any loop can be exited at any time with a special command called break. This is often used with so called infinite loop, a while loop that has 1 as a condition; recall that 1 means true, i.e. the loop condition always holds and the loop never ends. break allows us to place conditions in the middle of the loop and into multiple places. E.g.:
while (1) // infinite loop
{
x = x - 1;
if (x == 0)
break; // this exits the loop!
y = y / x;
}
The code above places a condition in the middle of an infinite loop to prevent division by zero in y = y / x.
Again, loops can be nested (we may have loops inside loops) and also loops can contain branches and vice versa.
With what we've learned so far we can already make a simple game: guess a number. The computer thinks a random number in range 0 to 9 and the user has to guess it. The source code is following.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void)
{
srand(clock()); // random seed
while (1) // infinite loop
{
int randomNumber = rand() % 10;
puts("I think a number. What is it?");
int guess;
scanf("%d",&guess); // read the guess
getchar();
if (guess == randomNumber)
puts("You guessed it!");
else
printf("Wrong. The number was %d.\n",randomNumber);
puts("Play on? [y/n]");
char answer;
scanf("%c",&answer); // read the answer
if (answer == 'n')
break;
}
puts("Bye.");
return 0; // return success, always here
}
#include <stdlib.h>, #include <time.h>: we're including additional libraries because we need some specific functions from them (rand, srand, clock).
srand(clock());: don't mind this line too much, its purpose is to seed a pseudorandom number generator. Without doing this the game would always generate the same sequence of random numbers when run again.
while (1) is an infinite game loop -- it runs over and over, in each cycle we perform one game round. The loop can be exited with the break statement later on (if the user answers he doesn't want to continue playing).
int randomNumber = rand() % 10;: this line declares a variable named randomNumber and immediately assigns a value to it. The value is a random number from 0 to 9. This is achieved with a function rand (from the above included stdlib library) which returns a random number, and with the modulo (remainder after division) arithmetic operator (%) which ensures the number is in the correct range (less than 10).
int guess; creates another variable in which we'll store the user's guessed number.
scanf("%d",&guess); reads a number from the input to the variable named guess. Again, don't be bothered by the complicated structure of this command, for now just accept that this is how it's done.
getchar();: don't mind this line, it just discards a newline character read from the input.
if (guess == randomNumber) ...: this is a branch which checks if the user guess is equal to the generated random number. If so, a success message is printed out. If not, a fail message is printed out along with the secret number. Note we use the puts function for the first message as it only prints a text string, while for the latter message we have to use printf, a more complex function, because that requires inserting a number into the printed string. More on these functions later.
char answer; declares a variable to store user's answer to a question of whether to play on. It is of char data type which can store a single text character.
scanf("%c",&answer); reads a single character from input to the answer variable.
if (answer == 'n') break; is a branch that exits the infinite loop with break statement if the answer entered was n (no).Functions are highly important in programming, no program besides the most primitive ones can be made without them (well, in theory any program can be created without functions, but in practice such programs would be too complicated, unreadable and unmaintainable).
Function is a subprogram (in other languages functions are also called procedures or subroutines), i.e. it is code that solves some smaller subproblem that you can repeatedly invoke, for instance you may have a function for computing a square root, for encrypting data or for playing a sound from speakers. We have already met functions such as puts, printf or rand.
Functions are similar to but NOT the same as mathematical functions. Mathematical function (simply put) takes a number on input and outputs another number computed from the input number, and the output number depends solely on the input number and nothing else. C functions can do this too but they can also do additional things such as modify variables in other parts of the program or make the computer do something (such as play a sound or display something on the screen) -- these are called side effects; things done besides computing an output number from an input number. For distinction mathematical functions are called pure functions and functions with side effects are called non-pure.
Why are function so important? Primarily they help us divide a big problem into small subproblems and make the code better organized and readable, but mainly they aid us in respecting the DRY (Don't Repeat Yourself) principle -- this is extremely important in programming. Imagine you need to solve a quadratic equation in several parts of your program; you do NOT want to solve it in each place separately, you want to make a function that solves a quadratic equation and then only invoke (call) that function anywhere you need to solve your quadratic equation. This firstly saves space (source code will be shorter and compiled program will be smaller), but it also makes your program manageable and eliminates bugs -- imagine you find a better (e.g. faster) way to solving quadratic equations; without functions you'd have to go through the whole code and change the algorithm in each place separately which is impractical and increases the chance of making errors. With functions you only change the code in one place (in the function) and in any place where your code invokes (calls) this function the new better and updated version of the function will be used.
Besides writing programs that can be directly executed programmers also write so called libraries -- collections of functions (and possibly similar things like macros etc.) that can be used in other projects. We have already seen libraries such as stdio, standard input/output library, a standard (official, should be bundled with every C compiler) library for input/output (reading and printing values); stdio contains functions such as puts which is used to printing out text strings. Examples of other libraries are the standard math library containing function for e.g. computing sine, or SDL, a 3rd party multimedia library for such things as drawing to screen, playing sounds and handling keyboard and mouse input.
Let's see a simple example of a function that writes out a temperature in degrees of Celsius as well as in Kelvin:
#include <stdio.h>
void writeTemperature(int celsius)
{
int kelvin = celsius + 273;
printf("%d C (%d K)\n",celsius,kelvin);
}
int main(void)
{
writeTemperature(-50);
writeTemperature(0);
writeTemperature(100);
return 0;
}
The output is
-50 C (223 K) 0 C (273 K) 100 C (373 K)
Now imagine we decide we also want our temperatures in Fahrenheit. We can simply edit the code in writeTemperature function and the program will automatically be writing temperatures in the new way.
Let's see how to create and invoke functions. Creating a function in code is typically done between inclusion of libraries and the main function, and we formally call this defining a function. The function definition format is following:
RETURN_TYPE FUNCTION_NAME(FUNCTION_PARAMETERS)
{
FUNCTION_BODY
}
RETURN_TYPE is the data type the function returns. A function may or may not return a certain value, just as the pure mathematical function do. This may for example be int, if the function returns an integer number. If the function doesn't return anything, this type is void.
FUNCTION_NAME is the name of the function, it follows the same rules as the names for variables.
FUNCTION_PARAMETERS specifies the input values of the function. The function can take any number of parameters (e.g. a function playBeep may take 0 arguments, sine function takes 1, logarithm may take two etc.). This list is comma-separated and each item consists of the parameter data type and name. If there are 0 parameters, there should be the word void inside the brackets, but compilers tolerate just having empty brackets.
FUNCTION_BODY are the commands executed by the function, just as we know them from the main function.Let's see another function:
#include <stdio.h>
int power(int x, int n)
{
int result = 1;
for (int i = 0; i < n; ++i) // repeat n times
result = result * x;
return result;
}
int main(void)
{
for (int i = 0; i < 5; ++i)
{
int powerOfTwo = power(2,i);
printf("%d\n",powerOfTwo);
}
return 0;
}
The output is:
1 2 4 8 16
The function power takes two parameters: x and n, and returns x raised to the ns power. Note that unlike the first function we saw here the return type is int because this function does return a value. Notice the command return -- it is a special command that causes the function to terminate and return a specific value. In functions that return a value (their return type is not void) there has to be a return command. In a function that returns nothing there may or may not be one, and if there is, it has no value after it (return;);
Let's focus on how we invoke the function -- in programming we say we call the function. The function call in our code is power(2,i). If a function returns a value (return type is not void), its function call can be used in any expression, i.e. almost anywhere where we can use a variable or a numerical value -- just imagine the function computes a return value and this value is substituted to the place where we call the function. For example we can imagine the expression power(3,1) + power(3,0) as simply 3 + 1.
If a function returns nothing (return type is void), it can't be used in expressions, it is used "by itself"; e.g. playBeep();. (Function that do return a value can also be used like this -- their return value is in this case simply ignored.)
We call a function by writing its name (power), then adding brackets (( and )) and inside them we put arguments -- specific values that will substitute the corresponding parameters inside the function (here x will take the value 2 and n will take the current value of i). If the function takes no parameters (the function parameter list is void), we simply put nothing inside the brackets (e.g. playBeep(););
Here comes the nice thing: we can nest function calls. For example we can write x = power(3,power(2,1)); which will result in assigning the variable x the value of 9. Functions can also call other functions (even themselves, see recursion), but only those that have been defined before them in the source code (this can be fixed with so called forward declarations).
Notice that the main function we always have in our programs is also a function definition. The definition of this function is required for runnable programs, its name has to be main and it has to return int (an error code where 0 means no error). It can also take parameters but more on that later.
This is the most basic knowledge to have about C functions. Let's see one more example with some pecularities that aren't so important now, but will be later.
#include <stdio.h>
void writeFactors(int x) // writes divisors of x
{
printf("factors of %d:\n",x);
while (x > 1) // keep dividing x by its factors
{
for (int i = 2; i <= x; ++i) // search for a factor
if (x % i == 0) // i divides x without remainder?
{
printf(" %d\n",i); // i is a factor, write it
x = x / i; // divide x by i
break; // exit the for loop
}
}
}
int readNumber(void)
{
int number;
puts("Please enter a number to factor (0 to quit).");
scanf("%d",&number);
return number;
}
int main(void)
{
while (1) // infinite loop
{
int number = readNumber(); // <- function call
if (number == 0) // 0 means quit
break;
writeFactors(number); // <- function call
}
return 0;
}
We have defined two functions: writeFactors and readNumber. writeFactors return no values but it has side effects (print text to the command line). readNumber takes no parameters but return a value; it prompts the user to enter a value and returns the read value.
Notice that inside writeFactors we modify its parameter x inside the function body -- this is okay, it won't affect the argument that was passed to this function (the number variable inside the main function won't change after this function call). x can be seen as a local variable of the function, i.e. a variable that's created inside this function and can only be used inside it -- when writeFactors is called inside main, a new local variable x is created inside writeFactors and the value of number is copied to it.
Another local variable is number -- it is a local variable both in main and in readNumber. Even though the names are the same, these are two different variables, each one is local to its respective function (modifying number inside readNumber won't affect number inside main and vice versa).
And a last thing: keep in mind that not every command you write in C program is a function call. E.g. control structures (if, while, ...) and special commands (return, break, ...) are not function calls.
We've skipped a lot of details and small tricks for simplicity. Let's go over some of them. Many of the following things are so called syntactic sugar: convenient syntax shorthands for common operations.
Multiple variables can be defined and assigned like this:
int x = 1, y = 2, z;
The meaning should be clear, but let's mention that z doesn't generally have a defined value here -- it will have a value but you don't know what it is (this may differ between different computers and platforms). See undefined behavior.
The following is a shorthand for using operators:
x += 1; // same as: x = x + 1; x -= 10; // same as: x = x - 1; x *= x + 1; // same as: x = x * (x + 1); x++; // same as: x = x + 1; x--; // same as: x = x - 1; // etc.
The last two constructs are called incrementing and decrementing. This just means adding/subtracting 1.
In C there is a pretty unique operator called the ternary operator (ternary for having three operands). It can be used in expressions just as any other operators such as + or -. Its format is:
CONDITION ? VALUE1 : VALUE2
It evaluates the CONDITION and if it's true (non-0), this whole expression will have the value of VALUE1, otherwise its value will be VALUE2. It allows for not using so many ifs. For example instead of
if (x >= 10) x -= 10; else x = 10;
we can write
x = x >= 10 ? x - 10 : 10;
Global variables: we can create variables even outside function bodies. Recall than variables inside functions are called local; variables outside functions are called global -- they can basically be accessed from anywhere and can sometimes be useful. For example:
#include <stdio.h>
#include <stdlib.h> // for rand()
int money = 0; // total money, global variable
void printMoney(void)
{
printf("I currently have $%d.\n",money);
}
void playLottery(void)
{
puts("I'm playing lottery.");
money -= 10; // price of lottery ticket
if (rand() % 5) // 1 in 5 chance
{
money += 100;
puts("I've won!");
}
else
puts("I've lost!");
printMoney();
}
void work(void)
{
puts("I'm going to work :(");
money += 200; // salary
printMoney();
}
int main(void)
{
work();
playLottery();
work();
playLottery();
return 0;
}
In C programs you may encounter a switch statement -- it is a control structure similar to a branch if which can have more than two branches. It looks like this:
switch (x)
{
case 0: puts("X is zero. Don't divide by it."); break;
case 69: puts("X is 69, haha."); break;
case 42: puts("X is 42, the answer to everything."); break;
default: printf("I don't know anything about X."); break;
}
Switch can only compare exact values, it can't e.g. check if a value is greater than something. Each branch starts with the keyword case, then the match value follows, then there is a colon (:) and the branch commands follow. IMPORTANT: there has to be the break; statement at the end of each case branch (we won't go into details). A special branch is the one starting with the word default that is executed if no case label was matched.
NOTE: Why does switch statement exist and why is it so weird? It may seem a little arbitrary and weird, especially when with several if statements we can achieve the same things and can use more general conditions. Switch statement isn't just syntactic sugar, it normally gets translated to different instructions and using switch for checking many conditions at once will be typically much faster than using if statements. Basically switch internally creates a table that will allow the program to jump instantly to the correct label, avoiding checking conditions one by one.
Let's also mention some additional data types we can use in programs:
char: A single text character such as 'a', 'G' or '_'. We can assign characters as char c = 'a'; (single characters are enclosed in apostrophes similarly to how text strings are inside quotes). We can read a character as c = getchar(); and print it as putchar(c);. Special characters that can be used are \n (newline) or \t (tab). Characters are in fact small numbers (usually with 256 possible values) and can be used basically anywhere a number can be used (for example we can compare characters, e.g. if (c < 'b') ...). Later we'll see characters are basic building blocks of text strings.
unsigned int: Integer that can only take positive values or 0 (i.e. no negative values). It can store higher positive values than normal int (which is called a signed int).
long: Big integer, takes more memory but can store number in the range of at least a few billion.
float and double: Floating point number (double is bigger and more precise than float) -- an approximation of real numbers, i.e. numbers with a fractional part such as 2.5 or 0.0001. You can print these numbers as printf("%lf\n",x); and read them as scanf("%f",&x);.Here is a short example with the new data types:
#include <stdio.h>
int main(void)
{
char c;
float f;
puts("Enter character.");
c = getchar(); // read character
puts("Enter float.");
scanf("%f",&f);
printf("Your character is :%c.\n",c);
printf("Your float is %lf\n",f);
float fSquared = f * f;
int wholePart = f; // this can be done
printf("It's square is %lf.\n",fSquared);
printf("It's whole part is %d.\n",wholePart);
return 0;
}
Notice mainly how we can assign a float value into the variable of int type (int wholePart = f;). This can be done even the other way around and with many other types. C can do automatic type conversions (casting), but of course, some information may be lost in this process (e.g. the fractional part).
In the section about functions we said a function can only call a function that has been defined before it in the source code -- this is because the compiler read the file from start to finish and if you call a function that hasn't been defined yet, it simply doesn't know what to call. But sometimes we need to call a function that will be defined later, e.g. in cases where two functions call each other (function A calls function B in its code but function B also calls function A). For this there exist so called forward declarations -- a forward declaration is informing that a function of certain name (and with certain parameters etc.) will be defined later in the code. Forward declaration look the same as a function definition, but it doesn't have a body (the part between { and }), instead it is terminated with a semicolon (;). Here is an example:
#include <stdio.h>
void printDecorated2(int x, int fancy); // forward declaration
void printDecorated1(int x, int fancy)
{
putchar('~');
if (fancy)
printDecorated2(x,0); // would be error without f. decl.
else
printf("%d",x);
putchar('~');
}
void printDecorated2(int x, int fancy)
{
putchar('>');
if (fancy)
printDecorated1(x,0);
else
printf("%d",x);
putchar('<');
}
int main(void)
{
printDecorated1(10,1);
putchar('\n'); // newline
printDecorated2(20,1);
}
which prints
~>10<~ >~20~<
The functions printDecorated1 and printDecorated2 call each other, so this is the case when we have to use a forward declaration of printDecorated2. Also note the condition if (fancy) which is the same thing as if (fancy != 0) (imagine fancy being 1 and 0 and about what the condition evaluates to in each case).
And one more important thing: our program as a whole can be passed parameters when it's executed, which inside the program we can access as so called command line arguments (also known as flags, switches etc.). This is important especially under Unix operating systems where we run programs from command line and where programs often work in non-interactive ways and are composed into bigger programs (similarly to how we compose small C functions into one big program); command line arguments are similar to arguments we pass to functions, they can inform our program to behave in certain way, for example to open a certain config file at start, to run in fullscreen mode, to print help and so on. When we compile our programs with the gcc compiler, e.g. like gcc -o myprogram myprogram.c, all the text after gcc are in fact arguments telling gcc which program to compile, how to compile it, how to name the output and so on. To allow our program to receive these arguments we add two parameters to the main function, one called argc (argument count) of integer type, saying how many arguments we get, and another called argv (argument vector) of pointer to a pointer to char type (please don't get scared), holding an array of strings (each argument will be of string type). Operating system will automatically fill these arguments in when our program is started. Here is a short example demonstrating this:
#include <stdio.h>
int main(int argc, char **argv)
{
puts("You passed these arguments:");
for (int i = 0; i < argc; ++i)
printf("- \"%s\"\n",argv[i]);
return 0;
}
If you compile this program and run it e.g. like
./program hello these are "my arguments"
The program will output:
You passed these arguments: - "./program" - "hello" - "these" - "are" - "my arguments"
Things to notice here are following: we passed 4 arguments but got 5 -- the first argument is the path of our program itself, i.e. we will always get at least this argument. Then we also see that our arguments are separated by spaces, but if we put them into double quotes (like the last one), it will become just one argument, keeping the spaces (but not the quotes). For now this knowledge will suffice, you will most definitely encounter command line arguments in real programs -- now you know what they are.
So far we've only been writing programs into a single source code file (such as program.c). More complicated programs consist of multiple files and libraries -- we'll take a look at this now.
In C we normally deal with two types of source code files:
When we have multiple source code files, we typically have pairs of .c and .h files. E.g. if there is a library called mathfunctions, it will consist of files mathfunctions.c and mathfunctions.h. The .h file will contain the function headers (in the same manner as with forward declarations) and constants such as pi. The .c file will then contain the implementations of all the functions declared in the .h file. But why do we do this?
Firstly .h files may serve as a nice documentation of the library for programmers: you can simply open the .h file and see all the functions the library offers without having to skim over thousands of lines of code. Secondly this is for how multiple source code files are compiled into a single executable program.
Suppose now we're compiling a single file named program.c as we've been doing until now. The compilation consists of several steps:
printf).
So realize that when the compiler is compiling our program (program.c), which contains function such as printf from a separate library, it doesn't have the code of these functions available -- this code is not in our file. Recall that if we want to call a function, it must have been defined before and so in order for us to be able to call printf, the compiler must know about it. This is why we include the stdio library at the top of our source code with #include <stdio.h> -- this basically copy-pastes the content of the header file of the stdio library to the top of our source code file. In this header there are forward declarations of functions such as printf, so the compiler now knows about them (it knows their name, what they return and what parameters they take) and we can call them.
Let's see a small example. We'll have the following files (all in the same directory).
library.h (the header file):
// Returns the square of n. int square(int n);
library.c (the implementation file):
int square(int x)
{
// function implementation
return x * x;
}
program.c (main program):
#include <stdio.h>
#include "library.h"
int main(void)
{
int n = square(5);
printf("%d\n",n);
return 0;
}
NOTE: "library.h" here is between double quotes, unlike <stdio.h>. This just says we specify an absolute path to the file as it's not in the directory where installed libraries go.
Now we will manually compile the library and the final program. First let's compile the library, in command line run:
gcc -c -o library.o library.c
The -c flag tells the compiler to only compile the file, i.e. only generate the object (.o) file without trying to link it. After this command a file library.o should appear. Next we compile the main program in the same way:
gcc -c -o program.o program.c
This will generate the file program.o. Note that during this process the compiler is working only with the program.c file, it doesn't know the code of the function square, but it knows the function exists, what it returns and what parameter it takes thanks to us including the library header library.h with #include "library.h" (quotes are used instead of < and > to tell the compiler to look for the files in the current directory).
Now we have the file program.o in which the compiled main function resides and file library.o in which the compiled function square resides. We need to link them together. This is done like this:
gcc -o program program.o library.o
For linking we don't need to use any special flag, the compiler knows that if we give it several .o files, it is supposed to link them. The file program should appear that we can already run and it should print
25
This is the principle of compiling multiple C files (and it also allows for combining C with other languages). This process is normally automated, but you should know how it works. The systems that automate this action are called build systems, they are for example Make and Cmake. When using e.g. the Make system, the whole codebase can be built with a single command make in the command line.
Some programmers simplify this whole process further so that they don't even need a build system, e.g. with so called header-only libraries, but this is outside the scope of this tutorial.
As a bonus, let's see a few useful compiler flags:
-O1, -O2, -O3: Optimize for speed (higher number means better optimization). Adding -O3 normally instantly speeds up your program (but slows down compilation, so you may want to choose higher optimization only for releases etc.). This is recommended (watch out though: your program may grow in size).
-Os: Optimize for size, the same as above but the compiler will try to make as small executable as possible (this may be on detriment of execution speed).
-Wall -Wextra -pedantic: The compiler will write more warnings and will be more strict. This can help spot many bugs. It's highly recommended to always set these!
-c: Compile only (generate object files, do not link).
-g: Include debug symbols, this will be important for debugging. For non-release builds it's good to always turn this on.Until now we've encountered simple data types such as int, char or float. These identify values which can take single atomic values (e.g. numbers or text characters). Such data types are called primitive types.
Above these there exist compound data types (also complex or structured) which are composed of multiple primitive types. They are necessary for any advanced program.
The first compound type is a structure, or struct. It is a collection of several values of potentially different data types (primitive or compound). The following code shows how a struct can be created and used.
#include <stdio.h>
typedef struct
{
char initial; // initial of name
int weightKg;
int heightCm;
} Human;
int bmi(Human human)
{
return (human.weightKg * 10000) / (human.heightCm * human.heightCm);
}
int main(void)
{
Human carl;
carl.initial = 'C';
carl.weightKg = 100;
carl.heightCm = 180;
if (bmi(carl) > 25)
puts("Carl is fat.");
return 0;
}
The part of the code starting with typedef struct creates a new data type that we call Human (one convention for data type names is to start them with an uppercase character). This data type is a structure consisting of three members, one of type char and two of type int. Inside the main function we create a variable carl which is of Human data type. Then we set the specific values -- we see that each member of the struct can be accessed using the dot character (.), e.g. carl.weightKg; this can be used just as any other variable. Then we see the type Human being used in the parameter list of the function bmi, just as any other type would be used.
What is this good for? Why don't we just create global variables such as carl_initial, carl_weightKg and carl_heightCm? In this simple case it might work just as well, but in a more complex code this would be burdening -- imagine we wanted to create 10 variables of type Human (john, becky, arnold, ...). We would have to painstakingly create 30 variables (3 for each person), the function bmi would have to take two parameters (height and weight) instead of one (human) and if we wanted to e.g. add more information about every human (such as hairLength), we would have to manually create another 10 variables and add one parameter to the function bmi, while with a struct we only add one member to the struct definition and create more variables of type Human.
Structs can be nested. So you may see things such as myHouse.groundFloor.livingRoom.ceilingHeight in C code.
Another immensely important compound type is array -- a sequence of items, all of which are of the same data type. Each array is specified with its length (number of items) and the data type of the items. We can have, for instance, an array of 10 ints, or an array of 235 Humans. The important thing is that we can index the array, i.e. we access the individual items of the array by their position, and this position can be specified with a variable. This allows for looping over array items and performing certain operations on each item. Demonstration code follows:
#include <stdio.h>
#include <math.h> // for sqrt()
int main(void)
{
float vector[5];
vector[0] = 1;
vector[1] = 2.5;
vector[2] = 0;
vector[3] = 1.1;
vector[4] = -405.054;
puts("The vector is:");
for (int i = 0; i < 5; ++i)
printf("%lf ",vector[i]);
putchar('\n'); // newline
/* compute vector length with
pythagorean theorem: */
float sum = 0;
for (int i = 0; i < 5; ++i)
sum += vector[i] * vector[i];
printf("Vector length is: %lf\n",sqrt(sum));
return 0;
}
We've included a new library called math.h so that we can use a function for square root (sqrt). (If you have trouble compiling the code, add -lm flag to the compile command.)
`float vector[5]; is a declaration of an array of length 5 whose items are of type float. When compiler sees this, it creates a continuous area in memory long enough to store 5 numbers of float type, the numbers will reside here one after another.
After doing this, we can index the array with square brackets ([ and ]) like this: ARRAY_NAME[INDEX] where ARRAY_NAME is the name of the array (here vector) and INDEX is an expression that evaluates to integer, starting with 0 and going up to the vector length minus one (remember that programmers count from zero). So the first item of the array is at index 0, the second at index 1 etc. The index can be a numeric constant like 3, but also a variable or a whole expression such as x + 3 * myFunction(). Indexed array can be used just like any other variable, you can assign to it, you can use it in expressions etc. This is seen in the example. Trying to access an item beyond the array's bounds (e.g. vector[100]) will likely crash your program.
Especially important are the parts of code staring with for (int i = 0; i < 5; ++i): this is an iteration over the array. It's a very common pattern that we use whenever we need to perform some action with every item of the array.
Arrays can also be multidimensional, but we won't bothered with that right now.
Why are arrays so important? They allow us to work with great number of data, not just a handful of numeric variables. We can create an array of million structs and easily work with all of them thanks to indexing and loops, this would be practically impossible without arrays. Imagine e.g. a game of chess; it would be very silly to have 64 plain variables for each square of the board (squareA1, squareA2, ..., squareH8), it would be extremely difficult to work with such code. With an array we can represent the square as a single array, we can iterate over all the squares easily etc.
One more thing to mention about arrays is how they can be passed to functions. A function can have as a parameter an array of fixed or unknown length. There is also one exception with arrays as opposed to other types: if a function has an array as parameter and the function modifies this array, the array passed to the function (the argument) will be modified as well (we say that arrays are passed by reference while other types are passed by value). We know this wasn't the case with other parameters such as int -- for these the function makes a local copy that doesn't affect the argument passed to the function. The following example shows what's been said:
#include <stdio.h>
// prints an int array of length 10
void printArray10(int array[10])
{
for (int i = 0; i < 10; ++i)
printf("%d ",array[i]);
}
// prints an int array of arbitrary length
void printArrayN(int array[], int n)
{
for (int i = 0; i < n; ++i)
printf("%d ",array[i]);
}
// fills an array with numbers 0, 1, 2, ...
void fillArrayN(int array[], int n)
{
for (int i = 0; i < n; ++i)
array[i] = i;
}
int main(void)
{
int array10[10];
int array20[20];
fillArrayN(array10,10);
fillArrayN(array20,20);
printArray10(array10);
putchar('\n');
printArrayN(array20,20);
return 0;
}
The function printArray10 has a fixed length array as a parameter (int array[10]) while printArrayN takes as a parameter an array of unknown length (int array[]) plus one additional parameter to specify this length (so that the function knows how many items of the array it should print). The function printArray10 is important because it shows how a function can modify an array: when we call fillArrayN(array10,10); in the main function, the array array10 will be actually modified after when the function finishes (it will be filled with numbers 0, 1, 2, ...). This can't be done with other data types (though there is a trick involving pointers which we will learn later).
Now let's finally talk about text strings. We've already seen strings (such as "hello"), we know we can print them, but what are they really? A string is a data type, and from C's point of view strings are nothing but arrays of chars (text characters), i.e. sequences of chars in memory. In C every string has to end with a 0 char -- this is NOT '0' (whose ASCII value is 48) but the direct value 0 (remember that chars are really just numbers). The 0 char cannot be printed out, it is just a helper value to terminate strings. So to store a string "hello" in memory we need an array of length at least 6 -- one for each character plus one for the terminating 0. These types of string are called zero terminated strings (or C strings).
When we write a string such as "hello" in our source, the C compiler creates an array in memory for us and fills it with characters 'h', 'e', 'l', 'l', 'o', 0. In memory this may look like a sequence of numbers 104, 101, 108, 108 111, 0.
Why do we terminate strings with 0? Because functions that work with strings (such as puts or printf) don't know what length the string is. We can call puts("abc"); or puts("abcdefghijk"); -- the string passed to puts has different length in each case, and the function doesn't know this length. But thanks to these strings ending with 0, the function can compute the length, simply by counting characters from the beginning until it finds 0 (or more efficiently it simply prints characters until it finds 0).
The syntax that allows us to create strings with double quotes (") is just a helper (syntactic sugar); we can create strings just as any other array, and we can work with them the same. Let's see an example:
#include <stdio.h>
int main(void)
{
char alphabet[27]; // 26 places for letters + 1 for temrinating 0
for (int i = 0; i < 26; ++i)
alphabet[i] = 'A' + i;
alphabet[26] = 0; // terminate the string
puts(alphabet);
return 0;
}
`alphabet is an array of chars, i.e. a string. Its length is 27 because we need 26 places for letters and one extra space for the terminating 0. Here it's important to remind ourselves that we count from 0, so the alphabet can be indexed from 0 to 26, i.e. 26 is the last index we can use, doing alphabet[27] would be an error! Next we fill the array with letters (see how we can treat chars as numbers and do 'A' + i). We iterate while i < 26, i.e. we will fill all the places in the array up to the index 25 (including) and leave the last place (with index 26) empty for the terminating 0. That we subsequently assign. And finally we print the string with puts(alphabet) -- here note that there are no double quotes around alphabet because its a variable name. Doing puts("alphabet") would cause the program to literally print out alphabet. Now the program outputs:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
In C there is a standard library for working with strings called string (#include <string.h>), it contains such function as strlen for computing string length or strcmp for comparing strings.
One final example -- a creature generator -- will show all the three new data types in action:
#include <stdio.h>
#include <stdlib.h> // for rand()
typedef struct
{
char name[4]; // 3 letter name + 1 place for 0
int weightKg;
int legCount;
} Creature; // some weird creature
Creature creatures[100]; // global array of Creatures
void printCreature(Creature c)
{
printf("Creature named %s ",c.name); // %s prints a string
printf("(%d kg, ",c.weightKg);
printf("%d legs)\n",c.legCount);
}
int main(void)
{
// generate random creatures:
for (int i = 0; i < 100; ++i)
{
Creature c;
c.name[0] = 'A' + (rand() % 26);
c.name[1] = 'a' + (rand() % 26);
c.name[2] = 'a' + (rand() % 26);
c.name[3] = 0; // terminate the string
c.weightKg = 1 + (rand() % 1000);
c.legCount = 1 + (rand() % 10); // 1 to 10 legs
creatures[i] = c;
}
// print the creatures:
for (int i = 0; i < 100; ++i)
printCreature(creatures[i]);
return 0;
}
When run you will see a list of 100 randomly generated creatures which may start e.g. as:
Creature named Nwl (916 kg, 4 legs) Creature named Bmq (650 kg, 2 legs) Creature named Cda (60 kg, 4 legs) Creature named Owk (173 kg, 7 legs) Creature named Hid (430 kg, 3 legs) ...
The C language comes with a feature called preprocessor which is necessary for some advanced things. It allows automated modification of the source code before it is compiled.
Remember how we said that compiler compiles C programs in several steps such as generating object files and linking? There is one more step we didn't mention: preprocessing. It is the very first step -- the source code you give to the compiler first goes to the preprocessor which modifies it according to special commands in the source code called preprocessor directives. The result of preprocessing is a pure C code without any more preprocessing directives, and this is handed over to the actual compilation.
The preprocessor is like a mini language on top of the C language, it has its own commands and rules, but it's much more simple than C itself, for example it has no data types or loops.
Each directive begins with #, is followed by the directive name and continues until the end of the line (\ can be used to extend the directive to the next line).
We have already encountered one preprocessor directive: the #include directive when we included library header files. This directive pastes a text of the file whose name it is handed to the place of the directive.
Another directive is #define which creates so called macro -- in its basic form a macro is nothing else than an alias, a nickname for some text. This is used to create constants. Consider the following code:
#include <stdio.h>
#define ARRAY_SIZE 10
int array[ARRAY_SIZE];
void fillArray(void)
{
for (int i = 0; i < ARRAY_SIZE; ++i)
array[i] = i;
}
void printArray(void)
{
for (int i = 0; i < ARRAY_SIZE; ++i)
printf("%d ",array[i]);
}
int main(void)
{
fillArray();
printArray();
return 0;
}
`#define ARRAY_SIZE 10 creates a macro that can be seen as a constant named ARRAY_SIZE which stands for 10. From this line on any occurrence of ARRAY_SIZE that the preprocessor encounters in the code will be replaced with 10. The reason for doing this is obvious -- we respect the [DRY](dry.md) (don't repeat yourself) principle, if we didn't use a constant for the array size and used the direct numeric value 10 in different parts of the code, it would be difficult to change them all later, especially in a very long code, there's a danger we'd miss some. With a constant it is enough to change one line in the code (e.g. #define ARRAY_SIZE 10 to #define ARRAY_SIZE 20).
The macro substitution is literally a glorified copy-paste text replacement, there is nothing very complex going on. This means you can create a nickname for almost anything (for example you could do #define when if and then also use when in place of if -- but it's probably not a very good idea). By convention macro names are to be ALL_UPPER_CASE (so that whenever you see an all upper case word in the source code, you know it's a macro).
Macros can optionally take parameters similarly to functions. There are no data types, just parameter names. The usage is demonstrated by the following code:
#include <stdio.h>
#define MEAN3(a,b,c) (((a) + (b) + (c)) / 3)
int main(void)
{
int n = MEAN3(10,20,25);
printf("%d\n",n);
return 0;
}
`MEAN3 computes the mean of 3 values. Again, it's just text replacement, so the line int n = MEAN3(10,20,25); becomes int n = (((10) + (20) + (25)) / 3); before code compilation. Why are there so many brackets in the macro? It's always good to put brackets over a macro and all its parameters because the parameters are again a simple text replacement; consider e.g. a macro #define HALF(x) x / 2 -- if it was invoked as HALF(5 + 1), the substitution would result in the final text 5 + 1 / 2, which gives 5 (instead of the intended value 3).
You may be asking why would we use a macro when we can use a function for computing the mean? Firstly macros don't just have to work with numbers, they can be used to generate parts of the source code in ways that functions can't. Secondly using a macro may sometimes be simpler, it's shorter and will be faster to execute because there is no function call (which has a slight overhead) and because the macro expansion may lead to the compiler precomputing expressions at compile time. But beware: macros are usually worse than functions and should only be used in very justified cases. For example macros don't know about data types and cannot check them, and they also result in a bigger compiled executable (function code is in the executable only once whereas the macro is expanded in each place where it is used and so the code it generates multiplies).
Another very useful directive is #if for conditional inclusion or exclusion of parts of the source code. It is similar to the C if command. The following example shows its use:
#include <stdio.h>
#define RUDE 0
void printNumber(int x)
{
puts(
#if RUDE
"You idiot, the number is:"
#else
"The number is:"
#endif
);
printf("%d\n",x);
}
int main(void)
{
printNumber(3);
printNumber(100);
#if RUDE
puts("Bye bitch.");
#endif
return 0;
}
When run, we get the output:
The number is: 3 The number is: 100
And if we change #define RUDE 0 to #define RUDE 1, we get:
You idiot, the number is: 3 You idiot, the number is: 100 Bye bitch.
We see the #if directive has to have a corresponding #endif directive that terminates it, and there can be an optional #else directive for an else branch. The condition after #if can use similar operators as those in C itself (+, ==, &&, || etc.). There also exists an #ifdef directive which is used the same and checks if a macro of given name has been defined.
`#if directives are very useful for conditional compilation, they allow for creation of various "settings" and parameters that can fine-tune a program -- you may turn specific features on and off with this directive. It is also helpful for [portability](portability.md); compilers may automatically define specific macros depending on the platform (e.g. _WIN64, __APPLE__, ...) based on which you can trigger different code. E.g.:
#ifdef _WIN64
puts("Your OS sucks.");
#endif
Let us talk about one more thing that doesn't fall under the preprocessor language but is related to constants: enumerations. Enumeration is a data type that can have values that we specify individually, for example:
typedef enum
{
APPLE,
PEAR,
TOMATO
} Fruit;
This creates a new data type Fruit. Variables of this type may have values APPLE, PEAR or TOMATO, so we may for example do Fruit myFruit = APPLE;. These values are in fact integers and the names we give them are just nicknames, so here APPLE is equal to 0, PEAR to 1 and TOMATO to 2.
Pointers belong under advanced topics that many people fear -- many complain they're hard to learn, others complain about memory unsafety and potential "dangers" connected to pointers. These people are stupid, pointers are great. Let's dissect the subject bit by bit.
Beware still, there may be too much new information in the first read. Don't get scared, give it some time.
Pointers allow us to handle certain advanced tasks such as allocating dynamic memory, returning multiple values from functions, inspecting content of memory or using functions in similar ways in which we use variables.
The definition of a pointer is essentially nothing complicated: it is a data type that can hold a memory address (plus an information about what data type should be stored at that address). Address is nothing but a non-negative integer number. Why can't we just use an int to store a memory address? Because the size of int and a pointer may differ, the size of pointer depends on the size of the computer's address bus. Besides this, as said, a pointer actually holds not only an address but also the information about the type it points to, which is a safety mechanism that will become clear later. It is also good when the compiler knows a certain variable is supposed to point to a memory rather than to hold a generic number -- this can all prevent bugs. I.e. pointers and generic integers are distinguished for the same reason other data types are distinguished -- in theory they don't have to be distinguished, but it's safer.
It is important to stress again that a pointer is not a pure address but it also knows about the data type it is pointing to, so there are many kinds of pointers: a pointer to int, a pointer to char, a pointer to a specific struct type etc.
A variable of pointer type is created similarly to a normal variable, we just add * after the data type, for example int *x; creates a variable named x that is a pointer to int (some people would write this as int* x;).
But how do we assign a value to the pointer? To do this, we need an address of something, e.g. of some variable. To get an address of a variable we use the & character, i.e. &a is the address of a variable a.
The last basic thing we need to know is how to dereference a pointer. Dereferencing means accessing the value at the address that's stored in the pointer, i.e. working with the pointed to value. This is again done (maybe a bit confusingly) with * character in front of a pointer, e.g. if x is a pointer to int, *x is the int value to which the pointer is pointing. An example can perhaps make it clearer.
#include <stdio.h>
int main(void)
{
int normalVariable = 10;
int *pointer;
pointer = &normalVariable;
printf("address in pointer: %p\n",pointer);
printf("value at this address: %d\n",*pointer);
*pointer = *pointer + 10;
printf("normalVariable: %d\n",normalVariable);
return 0;
}
This may print e.g.:
address in pointer: 0x7fff226fe2ec value at this address: 10 normalVariable: 20
`int pointer; creates a pointer to int with name pointer. Next we make the pointer point to the variable normalVariable, i.e. we get the address of the variable with &normalVariable and assign it normally to pointer. Next we print firstly the address in the pointer (accessed with pointer) and the value at this address, for which we use dereference as pointer. At the next line we see that we can also use dereference for writing to the pointed address, i.e. doing pointer = *pointer + 10; here is the same as doing normalVariable = normalVariable + 10;. The last line shows that the value in normalVariable has indeed changed.
IMPORTANT NOTE: You generally cannot read and write from/to random addresses! This will crash your program. To be able to write to a certain address it must be allocated, i.e. reserved for use. Addresses of variables are allocated by the compiler and can be safely operated with.
There's a special value called NULL (a macro defined in the standard library) that is meant to be assigned to pointer that points to "nothing". So when we have a pointer p that's currently not supposed to point to anything, we do p = NULL;. In a safe code we should always check (with if) whether a pointer is not NULL before dereferencing it, and if it is, then NOT dereference it. This isn't required but is considered a "good practice" in safe code, storing NULL in pointers that point nowhere prevents dereferencing random or unallocated addresses which would crash the program.
But what can pointers be good for? Many things, for example we can kind of "store variables in variables", i.e. a pointer is a variable which says which variable we are now using, and we can switch between variable any time. E.g.:
#include <stdio.h>
int bankAccountMonica = 1000;
int bankAccountBob = -550;
int bankAccountJose = 700;
int *payingAccount; // pointer to who's currently paying
void payBills(void)
{
*payingAccount -= 200;
}
void buyFood(void)
{
*payingAccount -= 50;
}
void buyGas(void)
{
*payingAccount -= 20;
}
int main(void)
{
// let Jose pay first
payingAccount = &bankAccountJose;
payBills();
buyFood();
buyGas();
// that's enough, now let Monica pay
payingAccount = &bankAccountMonica;
buyFood();
buyGas();
buyFood();
buyFood();
// now it's Bob's turn
payingAccount = &bankAccountBob;
payBills();
buyFood();
buyFood();
buyGas();
printf("Monika has $%d left.\n",bankAccountMonica);
printf("Jose has $%d left.\n",bankAccountJose);
printf("Bob has $%d left.\n",bankAccountBob);
return 0;
}
Well, this could be similarly achieved with arrays, but pointers have more uses. For example they allow us to return multiple values by a function. Again, remember that we said that (with the exception of arrays) a function cannot modify a variable passed to it because it always makes its own local copy of it? We can bypass this by, instead of giving the function the value of the variable, giving it the address of the variable. The function can read the value of that variable (with dereference) but it can also CHANGE the value, it simply writes a new value to that address (again, using dereference). This example shows it:
#include <stdio.h>
#include <math.h>
#define PI 3.141592
// returns 2D coordinates of a point on a unit circle
void getUnitCirclePoint(float angle, float *x, float *y)
{
*x = sin(angle);
*y = cos(angle);
}
int main(void)
{
for (int i = 0; i < 8; ++i)
{
float pointX, pointY;
getUnitCirclePoint(i * 0.125 * 2 * PI,&pointX,&pointY);
printf("%lf %lf\n",pointX,pointY);
}
return 0;
}
Function getUnitCirclePoint doesn't return any value in the strict sense, but thank to pointers it effectively returns two float values via its parameters x and y. These parameters are of the data type pointer to float (as there's * in front of them). When we call the function with getUnitCirclePoint(i * 0.125 * 2 * PI,&pointX,&pointY);, we hand over the addresses of the variables pointX and pointY (which belong to the main function and couldn't normally be accessed in getUnitCirclePoint). The function can then compute values and write them to these addresses (with dereference, *x and *y), changing the values in pointX and pointY, effectively returning two values.
Now let's take a look at pointers to structs. Everything basically works the same here, but there's one thing to know about, a syntactic sugar known as an arrow (->). Example:
#include <stdio.h>
typedef struct
{
int a;
int b;
} SomeStruct;
SomeStruct s;
SomeStruct *sPointer;
int main(void)
{
sPointer = &s;
(*sPointer).a = 10; // without arrow
sPointer->b = 20; // same as (*sPointer).b = 20
printf("%d\n",s.a);
printf("%d\n",s.b);
return 0;
}
Here we are trying to write values to a struct through pointers. Without using the arrow we can simply dereference the pointer with *, put brackets around and access the member of the struct normally. This shows the line (*sPointer).a = 10;. Using an arrow achieves the same thing but is perhaps a bit more readable, as seen in the line sPointer->b = 20;. The arrow is simply a special shorthand and doesn't need any brackets.
Now let's talk about arrays -- these are a bit special. The important thing is that an array is itself basically a pointer. What does this mean? If we create an array, let's say int myArray[10];, then myArray is basically a pointer to int in which the address of the first array item is stored. When we index the array, e.g. like myArray[3] = 1;, behind the scenes there is basically a dereference because the index 3 means: 3 places after the address pointed to by myArray. So when we index an array, the compiler takes the address stored in myArray (the address of the array start) and adds 3 to it (well, kind of) by which it gets the address of the item we want to access, and then dereferences this address.
Arrays and pointer are kind of a duality -- we can also use array indexing with pointers. For example if we have a pointer declared as int *x;, we can access the value x points to with a dereference (*x), but ALSO with indexing like this: x[0]. Accessing index 0 simply means: take the value stored in the variable and add 0 to it, then dereference it. So it achieves the same thing. We can also use higher indices (e.g. x[10]), BUT ONLY if x actually points to a memory that has at least 11 allocated places.
I LIKE UNDEVELOPED TITS.
This leads to a concept called pointer arithmetic. Pointer arithmetic simply means we can add or subtract numbers to pointer values. If we continue with the same pointer as above (int *x;), we can actually add numbers to it like *(x + 1) = 10;. What does this mean?! It means exactly the same thing as x[1]. Adding a number to a pointer shifts that pointer given number of places forward. We use the word places because each data type takes a different space in memory, for example char takes one byte of memory while int takes usually 4 (but not always), so shifting a pointer by N places means adding N times the size of the pointed to data type to the address stored in the pointer.
This may be a lot information to digest. Let's provide an example to show all this in practice:
#include <stdio.h>
// our own string print function
void printString(char *s)
{
int position = 0;
while (s[position] != 0)
{
putchar(s[position]);
position += 1;
}
}
// returns the length of string s
int stringLength(char *s)
{
int length = 0;
while (*s != 0) // count until terminating 0
{
length += 1;
s += 1; // shift the pointer one character to right
}
return length;
}
int main(void)
{
char testString[] = "catdog";
printString("The string '");
printString(testString);
printString("' has length ");
int l = stringLength(testString);
printf("%d.",l);
return 0;
}
The output is:
The string 'catdog' has length 6.
We've created a function for printing strings (printString) similar to puts and a function for computing the length of a string (stringLength). They both take as an argument a pointer to char, i.e. a string. In printString we use indexing ([ and ]) just as if s was an array, and indeed we see it works! In stringLength we similarly iterate over all characters in the string but we use dereference (*s) and pointer arithmetic (s += 1;). It doesn't matter which of the two styles we choose -- here we've shown both, for educational purposes. Finally notice that the string we actually work with is created in main as an array with char testString[] = "catdog"; -- here we don't need to specify the array size between [ and ] because we immediately assign a string literal to it ("catdog") and in such a case the compiler knows how big the array needs to be and automatically fills in the correct size.
Now that know about pointers, we can finally completely explain the functions from stdio we've been using:
int puts(char *s): A simple and fast function for printing a string (adds the newline character \n at the end).
int printf(char *format, ...): A little bit more complex function that can print not only strings but also other data types. It takes a variable number of parameters. The first one is always a string that specifies the print format -- this string can contain special sequences that will be replaced by textual representations of values we additionally provide as extra parameters after format. E.g. the sequence "%d" is replaced with a number obtained from the value of a corresponding int parameter. Similarly %c is for char, %s for strings, %p for pointers. Example: printf("MyInt = %d, myChar = %c, MyStr = %s\n",myInt,myChar,myStr);.
int getchar(void): Reads a single text character from the input and returns it. Why does the function return int and not char? Because the function can return additional special values such as EOF (end of file) which couldn't be stored in plain char.
int scanf(char *format, ...): Function for reading various data types from the input. Like printf it takes a variable number of parameters. The first one is a string that specifies which data type(s) to read -- this is a bit complicated but "%d" reads an int, "%f" float, "%c" char and "%s" string. The following arguments are pointers to expected data types, so e.g. if we've provided the format string "%d", a pointer to int has to follow. Through this parameter the value that's been read will be returned (in the same way we've seen in one example above).Now we'll take a look at how we can read and write from/to files on the computer disk which enables us to store information permanently or potentially process data such as images or audio. Files aren't so difficult.
We work with files through functions provided in the stdio library (so it has to be included). We distinguish two types of files:
From programmer's point of view there's actually not a huge difference between the two, they're both just sequences of characters or bytes (which are kind of almost the same). Text files are a little more abstract, they handle potentially different format of newlines etc. The main thing for us is that we'll use slightly different functions for each type.
There is a special data type for file called FILE (we'll be using a pointer to it). Whatever file we work with, we need to firstly open it with the function fopen and when we're done with it, we need to close it with a function fclose.
First we'll write something to a text file:
#include <stdio.h>
int main(void)
{
FILE *textFile = fopen("test.txt","w"); // "w" for write
if (textFile != NULL) // if opened successfully
fprintf(textFile,"Hello file.");
else
puts("ERROR: Couldn't open file.");
fclose(textFile);
return 0;
}
When run, the program should create a new file named test.txt in the same directory we're in and in it you should find the text Hello file.. FILE *textFile creates a new variable textFile which is a pointer to the FILE data type. We are using a pointer simply because the standard library is designed this way, its functions work with pointers (it can be more efficient). fopen("test.txt","w"); attempts to open the file test.txt in text mode for writing -- it returns a pointer that represents the opened file. The mode, i.e. text/binary, read/write etc., is specified by the second argument: "w"; w simply specifies write and the text mode is implicit (it doesn't have to be specified). if (textFile != NULL) checks if the file has been successfully opened; the function fopen returns NULL (the value of "point to nothing" pointers) if there was an error with opening the file (such as that the file doesn't exist). On success we write text to the file with a function fprintf -- it's basically the same as printf but works on files, so it's first parameter is always a pointer to a file to which it should write. You can of course also print numbers and anything that printf can with this function. Finally we mustn't forget to close the file at the end with fclose!
Now let's write another program that reads the file we've just created and writes its content out in the command line:
#include <stdio.h>
int main(void)
{
FILE *textFile = fopen("test.txt","r"); // "r" for read
if (textFile != NULL) // if opened successfully
{
char c;
while (fscanf(textFile,"%c",&c) != EOF) // while not end of file
putchar(c);
}
else
puts("ERROR: Couldn't open file.");
fclose(textFile);
return 0;
}
Notice that in fopen we now specify "r" (read) as a mode. Again, we check if the file has been opened successfully (if (textFile != NULL)). If so, we use a while loop to read and print all characters from the file until we encounter the end of file. The reading of file characters is done with the fscanf function inside the loop's condition -- there's nothing preventing us from doing this. fscanf again works the same as scanf (so it can read other types than only chars), just on files (its first argument is the file to read from). On encountering end of file fscanf returns a special value EOF (which is macro constant defined in the standard library). Again, we must close the file at the end with fclose.
We will now write to a binary file:
#include <stdio.h>
int main(void)
{
unsigned char image[] = // image in ppm format
{
80, 54, 32, 53, 32, 53, 32, 50, 53, 53, 32,
255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255,
255,255,255, 0, 0, 0, 255,255,255, 0, 0, 0, 255,255,255,
255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255,
0, 0, 0, 255,255,255, 255,255,255, 255,255,255, 0, 0, 0,
255,255,255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255,255,255
};
FILE *binFile = fopen("image.ppm","wb");
if (binFile != NULL) // if opened successfully
fwrite(image,1,sizeof(image),binFile);
else
puts("ERROR: Couldn't open file.");
fclose(binFile);
return 0;
}
Okay, don't get scared, this example looks complex because it is trying to do a cool thing: it creates an image file! When run, it should produce a file named image.ppm which is a tiny 5x5 smiley face image in ppm format. You should be able to open the image in any good viewer (I wouldn't bet on Windows programs though). The image data was made manually and are stored in the image array. We don't need to understand the data, we just know we have some data we want to write to a file. Notice how we can manually initialize the array with values using { and } brackets. We open the file for writing and in binary mode, i.e. with a mode "wb", we check the success of the action and then write the whole array into the file with one function call. The function is name fwrite and is used for writing to binary files (as opposed to fprintf for text files). fwrite takes these parameters: pointer to the data to be written to the file, size of one data element (in bytes), number of data elements and a pointer to the file to write to. Our data is the image array and since "arrays are basically pointers", we provide it as the first argument. Next argument is 1 (unsigned char always takes 1 byte), then length of our array (sizeof is a special operator that substitutes the size of a variable in bytes -- since each item in our array takes 1 byte, sizeof(image) provides the number of items in the array), and the file pointer. At the end we close the file.
And finally we'll finish with reading this binary file back:
#include <stdio.h>
int main(void)
{
FILE *binFile = fopen("image.ppm","rb");
if (binFile != NULL) // if opened successfully
{
unsigned char byte;
while (fread(&byte,1,1,binFile))
printf("%d ",byte);
putchar('\n');
}
else
puts("ERROR: Couldn't open file.");
fclose(binFile);
return 0;
}
The file mode is now "rb" (read binary). For reading from binary files we use the fread function, similarly to how we used fscanf for reading from a text file. fread has these parameters: pointer where to store the read data (the memory must have sufficient space allocated!)), size of one data item, number of items to read and the pointer to the file which to read from. As the first argument we pass &byte, i.e. the address of the variable byte, next 1 (we want to read a single byte whose size in bytes is 1), 1 (we want to read one byte) and the file pointer. fread returns the number of items read, so the while condition holds as long as fread reads bytes; once we reach end of file, fread can no longer read anything and returns 0 (which in C is interpreted as a false value) and the loop ends. Again, we must close the file at the end.
There's more to be known about functions.
An important concept in programming is recursion -- the situation in which a function calls itself. Yes, it is possible, but some rules have to be followed.
When a function calls itself, we have to ensure that we won't end up in infinite recursion (i.e. the function calls itself which subsequently calls itself and so on until infinity). This crashes our program. There always has to be a terminating condition in a recursive function, i.e. an if branch that will eventually stop the function from calling itself again.
But what is this even good for? Recursion is actually very common in math and programming, many problems are recursive in nature. Many things are beautifully described with recursion (e.g. fractals). But remember: anything a recursion can achieve can also be achieved by iteration (loop) and vice versa. It's just that sometimes one is more elegant or more computationally efficient.
Let's see this on a typical example of the mathematical function called factorial. Factorial of N is defined as N x (N - 1) x (N - 2) x ... x 1. It can also be defined recursively as: factorial of N is 1 if N is 0, otherwise N times factorial of N - 1. Here is some code:
#include <stdio.h>
unsigned int factorialRecursive(unsigned int x)
{
if (x == 0) // terminating condition
return 1;
else
return x * factorialRecursive(x - 1);
}
unsigned int factorialIterative(unsigned int x)
{
unsigned int result = 1;
while (x > 1)
{
result *= x;
x--;
}
return result;
}
int main(void)
{
printf("%d %d\n",factorialRecursive(5),factorialIterative(5));
return 0;
}
`factorialIterative computes the factorial by iteration. factorialRecursive uses recursion -- it calls itself. The important thing is the recursion is guaranteed to end because every time the function calls itself, it passes a decremented argument so at one point the function will receive 0 in which case the terminating condition (if (x == 0)) will be triggered which will avoid the further recursive call.
It should be mentioned that performance-wise recursion is almost always worse than iteration (function calls have certain overhead), so in practice it is used sparingly. But in some cases it is very well justified (e.g. when it makes code much simpler while creating unnoticeable performance loss).
Another thing to mention is that we can have pointers to functions; this is an advanced topic so we'll stay at it just briefly. Function pointers are pretty powerful, they allow us to create so called callbacks: imagine we are using some GUI framework and we want to tell it what should happen when a user clicks on a specific button -- this is usually done by giving the framework a pointer to our custom function that it will be called by the framework whenever the button is clicked.
Dynamic memory allocation means the possibility of reserving additional memory (RAM) for our program at run time, whenever we need it. This is opposed to static memory allocation, i.e. reserving memory for use at compile time (when compiling, before the program runs). We've already been doing static allocation whenever we created a variable -- compiler automatically reserves as much memory for our variables as is needed. But what if we're writing a program but don't yet know how much memory it will need? Maybe the program will be reading a file but we don't know how big that file is going to be -- how much memory should we reserve? Dynamic allocation allows us to reserve this memory with functions when the program is actually runing and already knows how much of it should be reserved.
It must be known that dynamic allocation comes with a new kind of bug known as a memory leak. It happens when we reserve a memory and forget to free it after we no longer need it. If this happens e.g. in a loop, the program will continue to "grow", eat more and more RAM until operating system has no more to give. For this reason, as well as others such as simplicity, it may sometimes be better to go with only static allocation.
Anyway, let's see how we can allocate memory if we need to. We use mostly just two functions that are provided by the stdlib library. One is malloc which takes as an argument size of the memory we want to allocate (reserve) in bytes and returns a pointer to this allocated memory if successful or NULL if the memory couldn't be allocated (which in serious programs we should always check). The other function is free which frees the memory when we no longer need it (every allocated memory should be freed at some point) -- it takes as the only parameter a pointer to the memory we've previously allocated. There is also another function called realloc which serves to change the size of an already allocated memory: it takes a pointer the the allocated memory and the new size in byte, and returns the pointer to the resized memory.
Here is an example:
#include <stdio.h>
#include <stdlib.h>
#define ALLOCATION_CHUNK 32 // by how many bytes to resize
int main(void)
{
int charsRead = 0;
int resized = 0; // how many times we called realloc
char *inputChars = malloc(ALLOCATION_CHUNK * sizeof(char)); // first allocation
while (1) // read input characters
{
char c = getchar();
charsRead++;
if ((charsRead % ALLOCATION_CHUNK) == 0)
{
inputChars = // we need more space, resize the array
realloc(inputChars,(charsRead / ALLOCATION_CHUNK + 1) * ALLOCATION_CHUNK * sizeof(char));
resized++;
}
inputChars[charsRead - 1] = c;
if (c == '\n')
{
charsRead--; // don't count the last newline character
break;
}
}
puts("The string you entered backwards:");
while (charsRead > 0)
{
putchar(inputChars[charsRead - 1]);
charsRead--;
}
free(inputChars); // important!
putchar('\n');
printf("I had to resize the input buffer %d times.",resized);
return 0;
}
This code reads characters from the input and stores them in an array (inputChars) -- the array is dynamically resized if more characters are needed. (We restrain from calling the array inputChars a string because we never terminate it with 0, we couldn't print it with standard functions like puts.) At the end the entered characters are printed backwards (to prove we really stored all of them), and we print out how many times we needed to resize the array.
We define a constant (macro) ALLOCATION_CHUNK that says by how many characters we'll be resizing our character buffer. I.e. at the beginning we create a character buffer of size ALLOCATION_CHUNK and start reading input character into it. Once it fills up we resize the buffer by another ALLOCATION_CHUNK characters and so on. We could be resizing the buffer by single characters but that's usually inefficient (the function malloc may be quite complex and take some time to execute).
The line starting with char *inputChars = malloc(... creates a pointer to char -- our character buffer -- to which we assign a chunk of memory allocated with malloc. Its size is ALLOCATION_CHUNK * sizeof(char). Note that for simplicity we don't check if inputChars is not NULL, i.e. whether the allocation succeeded -- but in your program you should do it :) Then we enter the character reading loop inside which we check if the buffer has filled up (if ((charsRead % ALLOCATION_CHUNK) == 0)). If so, we used the realloc function to increase the size of the character buffer. The important thing is that once we exit the loop and print the characters stored in the buffer, we free the memory with free(inputChars); as we no longer need it.
Debugging means localizing and fixing bugs (errors) in your program. In practice there are always bugs, even in very short programs (you've probably already figured that out yourself), some small and insignificant and some pretty bad ones that make your program unusable, vulnerable or even dangerous.
There are two kinds of bugs: syntactic errors and semantic errors. A syntactic error is when you write something not obeying the C grammar, it's like a typo or grammatical error in a normal language -- these errors are very easy to detect and fix, a compiler won't be able to understand your program and will point you to the exact place where the error occurs. A semantic error can be much worse -- it's a logical error in the program; the program will compile and run but the program will behave differently than intended. The program may crash, leak memory, give wrong results, run slowly, corrupt files etc. These errors may be hard to spot and fix, especially when they happen in rare situations. We'll be only considering semantic errors from now on.
If we spot a bug, how do we fix it? The first thing is to find a way to replicate it, i.e. find the exact steps we need to make with the program to make the bug appear (e.g. "in the menu press keys A and B simultaneously", ...). Next we need to trace and locate which exact line or piece of code is causing the bug. This can either be done with the help of specialized debuggers such as gdb or valgrind, but there's usually a much easier way of using printing functions such as printf. (Still do check out the above mentioned debuggers, they're very helpful.)
Let's say your program crashes and you don't know at which line. You simply put prints such as printf("A\n"); and printf("B\n); at the beginning and end of a code you suspect might be causing the crash. Then you run the program: if A is printed but B isn't, you know the crash happened somewhere between the two prints, so you shift the B print a little bit up and so on until you find exactly after which line B stops printing -- this is the line that crashes the program. IMPORTANT NOTE: the prints have to have newline (\n) at the end, otherwise this method may not work because of output buffering.
Of course, you may use the prints in other ways, for example to detect at which place a value of variable changes to a wrong value. (Asserts are also good for keeping an eye on correct values of variables.)
What if the program isn't exactly crashing but is giving wrong results? Then you need to trace the program step by step (not exactly line by line, but maybe function by function) and check which step has a problem in it. If for example your game AI is behaving stupid, you firstly check (with prints) if it correctly detects its circumstances, then you check whether it makes the correct decision based on the circumstances, then you check whether the pathfinding algorithm finds the correct path etc. At each step you need to know what the correct behavior should be and you try to find where the behavior is broken.
Knowing how to fix a bug isn't everything, we also need to find the bugs in the first place. Testing is the process of searching for bugs by simply running and using the program. Remember, testing can't prove there are no bugs in the program, it can only prove bugs exist. You can do testing manually or automate the tests. Automated tests are very important for preventing so called regressions (so the tests are called regression tests). Regression happens when during further development you break some of its already working features (it is very common, don't think it won't be happening to you). Regression test (which can simply be just a normal C program) simply automatically checks whether the already implemented functions still give the same results as before (e.g. if sin(0) = 0 etc.). These tests should be run and pass before releasing any new version of the program (or even before any commit of new code).
Optimization is also a process of improving an already working program, but here we try to make the program more efficient -- the most common goal is to make the program faster, smaller or consume less RAM. This can be a very complex task, so we'll only mention it briefly.
The very basic thing we can do is to turn on automatic optimization with a compiler flag: -O3 for speed, -Os for program size (-O2 and -O1 are less aggressive speed optimizations). Yes, it's that simple, you simply add -O3 and your program gets magically faster. Remember that optimizations against different resources are often antagonistic, i.e. speeding up your program typically makes it consume more memory and vice versa. You need to choose. Optimizing manually is a great art. Let's suppose you are optimizing for speed -- the first, most important thing is to locate the part of code that's slowing down you program the most, so called bottleneck. That is the code you want to make faster. Trying to optimize non-bottlenecks doesn't speed up your program as a whole much; imagine you optimize a part of the code that takes 1% of total execution time by 200% -- your program will only get 0.5% faster. Bottlenecks can be found using profiling -- measuring the execution time of different parts of the program (e.g. each function). This can be done manually or with tools such a gprof. Once you know where to optimize, you try to apply different techniques: using algorithms with better time complexity, using look up tables, optimizing cache behavior and so on. This is beyond the scope of this tutorial.
Now comes the time for the final program to showcase what we've learned, so let's write a quite simple but possibly useful hex viewer. The program will allow us to interactively inspect bytes in any file, drawing their hexadecimal values along with their addresses, supporting one character commands to move within the file. If you want, you can take it and improve it as an exercise, for example by adding more viewing modes (showing decimal octal or ASCII values), maybe even allowing editing and saving the file. Here is the source code:
/* Simple interactive hex file viewer. */
#include <stdio.h>
#include <stdlib.h>
#define ROWS 10 // how many rows and columns to print at one screen
#define COLS 16
unsigned char *fileContent = NULL; // this will contain the loaded file
unsigned long long fileSize = 0; // size of fileContent in bytes
unsigned long long fileOffset = 0; // current offset within the file
const char *fileName = NULL;
// Loads file with given name into fileContent, returns 1 on success, 0 on fail.
int loadFile(const char *fileToOpen)
{
FILE *file = fopen(fileToOpen,"rb");
if (file == NULL)
return 0;
fseek(file,0L,SEEK_END); // get to the end of the file
fileSize = ftell(file); // our position now says the size of the file
rewind(file); // get back to start of the file
fileContent = malloc(fileSize); // allocate memory to load the file into
if (fileContent == NULL)
{
fclose(file); // don't forget to close the file
return 0;
}
if (fread(fileContent,1,fileSize,file) != fileSize)
{
fclose(file);
free(fileContent);
return 0;
}
fclose(file);
return 1;
}
// Call when loaded file is no longer needed.
void unloadFile(void)
{
free(fileContent); // free the allocated memory
}
// Draws the current screen, i.e. hex view of the file at current offset.
void drawScreen(void)
{
for (int i = 0; i < 80; ++i) // scroll the old screen our of the view
putchar('\n');
printf("%s: %llu / %llu\n\n",fileName,fileOffset,fileSize);
unsigned long long offset = fileOffset;
for (int i = 0; i < ROWS * COLS; ++i)
{
if (offset % COLS == 0)
printf("%04X ",(int) offset);
if (offset < fileSize)
printf("%02X ",fileContent[offset]);
else
printf(".. ");
offset++;
if (offset % COLS == 0) // break line after each COLS values
putchar('\n');
}
}
int main(int argc, char **argv)
{
if (argc < 2)
{
puts("ERROR: please pass a file to open");
return 1;
}
fileName = argv[1]; // (argv[0] is the name of our program, we want argv[1])
if (!loadFile(fileName))
{
printf("ERROR: couldn't open the file \"%s\"\n",fileName);
return 1;
}
int goOn = 1;
while (goOn) // the main interactive loop
{
drawScreen();
puts("\ntype command (w = end, s = start, a = back, d = next, q = quit)");
char userInput = getchar();
switch (userInput)
{
case 'q':
goOn = 0;
break;
case 's':
if (fileOffset + COLS < fileSize)
fileOffset += COLS;
break;
case 'w':
if (fileOffset >= COLS)
fileOffset -= COLS;
break;
case 'a':
fileOffset = 0;
break;
case 'd':
fileOffset = ((fileSize - COLS) / COLS) * COLS; // aligns the offset
break;
default:
puts("unknown command, sorry");
break;
}
}
unloadFile();
return 0;
}
To append a few comments: the program opens a file whose name it gets passed as a command line argument, so it is used as: ./hexview myfile. We try to correctly perform all safety checks, e.g. if we actually get passed the file name, if we manage to open it and so on. Our program (a bit inefficiently) loads the whole file into memory (advanced programs only load parts of the file) -- for this it first checks the file size, allocates sufficient memory for it with malloc (also checking for errors) and loads it there. Then we have a function to draw the current file view and inside the main program body we have an interactive loop that loads and handles user commands and issues the view drawing. That is basically it!
Let's stress you should only get into graphics after you've written several purely command-line programs and are comfortable with the language. Don't try graphics programming until you can easily work with 2D arrays, structs and so on. Graphics is a huge topic of its own, there is so much we can't cover here, remember this is just a quick, basic starting point for making pictures with C.
For start please note that:
So, how to actually do graphics? As said, graphics is a super wide topic, there is no silver bullet, all depends on what we really need. Consider the following:
We will show an example of each of these approaches further on.
But first let's quickly mention what graphics programming at this level is essentially about, i.e. the kind of "workflow" we'll always try to implement:
drawPixel(x,y,color) -- graphic libraries will normally offer you a function like this, letting you draw pixels without actually caring about what magic is going on inside the function. (Sometimes you will also encounter a lower level way in which the library maps a screen to memory and you will draw pixels by literally writing values to memory, i.e. with pointers or arrays.)
drawLine(fromX,fromY,toX,toY,color), drawText(x,y,text,size,color) and so on. The picture itself is just a virtual canvas, a computer memory holding numbers, typically a two dimensional array whose values are manipulated by the drawPixel function. At this point we are doing nothing else than changing values in memory.
drawingDone(). Why can't the picture just be shown at all times? In theory it can, but you encounter problems, imagine e.g. a game that quickly redraws the picture on the screen -- here the user would see flickering, he might even see enemies show briefly behind a wall before the wall is actually drawn and so on. So a way to solve this is to do the drawing off screen and only at the end say "now we're done drawing, show the image" (for more details see double buffering).
Now let's finally get to writing the code. We'll set up some basic code for drawing a rectangle and try to draw it with different approaches.
The ASCII approach:
#include <stdio.h>
#define SCREEN_WIDTH 60
#define SCREEN_HEIGHT 25
char screen[SCREEN_WIDTH * SCREEN_HEIGHT]; // our virtual screen
// sets a single pixel at given coordinates
void drawPixel(int x, int y, char pixel)
{
int index = y * SCREEN_WIDTH + x;
if (index >= 0 && index < SCREEN_WIDTH * SCREEN_HEIGHT)
screen[index] = pixel;
}
// presents the drawn picture on the screen
void drawScreen(void)
{
for (int i = 0; i < 30; ++i) // shift old picture out of view
putchar('\n');
const char *p = screen;
for (int y = 0; y < SCREEN_HEIGHT; ++y)
{
for (int x = 0; x < SCREEN_WIDTH; ++x)
{
putchar(*p);
p++;
}
putchar('\n');
}
}
// fills rectangle with given pixel value
void drawRectangle(int x, int y, int width, int height, char pixel)
{
for (int j = 0; j < height; ++j)
for (int i = 0; i < width; ++i)
drawPixel(x + i,y + j,pixel);
}
int main(void)
{
int quit = 0;
int playerX = SCREEN_WIDTH / 2, playerY = SCREEN_HEIGHT / 2;
while (!quit) // main game loop
{
drawRectangle(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,'.'); // clear screen with dots
drawRectangle(playerX - 2,playerY - 1,5,3,'X'); // draw player
drawScreen(); // present the picture
puts("enter command (w/s/a/d/q):");
char input = getchar();
switch (input)
{
case 'w': playerY--; break;
case 's': playerY++; break;
case 'a': playerX--; break;
case 'd': playerX++; break;
case 'q': quit = 1; break;
}
}
return 0;
}
With this we have a simple interactive program that draws a dotted screen with rectangle representing the player, you can compile it like any other program, it uses no external libraries. User can move the rectangle around by typing commands. There is a main infinite loop (this is the above mentioned game loop, a typical thing in interactive applications) in which we read the user commands and redraw the picture on the screen. Notice we have our basic drawPixel function as well as the drawScreen function for presenting the finished picture, we also have a helper drawRectangle function. The screen array represents our virtual picture (it is declared as one dimensional array but in reality it is treated as two dimensional by the setPixel function). As an exercise you can try to draw other simple shapes, for example horizontal and vertical lines, non-filled rectangles -- if you're brave enough you can also try a filled circle (hint: points inside a circle mustn't be further away from the center than the circle radius).
Now let's try to do something similar, but this time creating a "real picture" made of true pixels, exported to a file:
#include <stdio.h>
#define SCREEN_WIDTH 640 // picture resolution
#define SCREEN_HEIGHT 480
unsigned char screen[SCREEN_WIDTH * SCREEN_HEIGHT * 3]; // screen, 3 is for RGB
// sets a single pixel at given coordinates
void drawPixel(int x, int y, int red, int green, int blue)
{
int index = y * SCREEN_WIDTH + x;
if (index >= 0 && index < SCREEN_WIDTH * SCREEN_HEIGHT)
{
index *= 3;
screen[index] = red;
screen[index + 1] = green;
screen[index + 2] = blue;
}
}
// outputs the image in PPM format
void outputPPM(void)
{
printf("P6 %d %d 255\n",SCREEN_WIDTH,SCREEN_HEIGHT); // PPM file header
for (int i = 0; i < SCREEN_WIDTH * SCREEN_HEIGHT * 3; ++i)
putchar(screen[i]);
}
// fills rectangle with given pixel
void drawRectangle(int x, int y, int width, int height, int red, int green,
int blue)
{
for (int j = 0; j < height; ++j)
for (int i = 0; i < width; ++i)
drawPixel(x + i,y + j,red,green,blue);
}
int main(void)
{
drawRectangle(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,128,128,128); // clear with grey
drawRectangle(SCREEN_WIDTH / 2 - 32, SCREEN_HEIGHT / 2 - 32,64,64,255,0,0);
outputPPM();
return 0;
}
Wow, this is yet simpler! Although we have no interactivity now, we get a nice picture of a red rectangle on grey background, and don't even need any library (not even the file library!)). We just compile this and save the program output to a file, e.g. with ./program > picture.ppm. The picture we get is stored in PPM format -- a very simple format that basically just stores raw RGB values and can be opened in many viewers and editors (e.g. GIMP). Notice the similar functions like drawPixel -- we only have a different parameter for the pixel (in ASCII example it was a single ASCII character, now we have 3 color values: red, green and blue). In the main program we also don't have any infinite loop, the program is non-interactive.
And now finally to the more complex example of a fully interactive graphic using SDL2:
#include <SDL2/SDL.h> // include SDL library
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define COLOR_WHITE 0xff // some colors in RGB332 format
#define COLOR_RED 0xe0
unsigned char _SDL_screen[SCREEN_WIDTH * SCREEN_HEIGHT];
SDL_Window *_SDL_window;
SDL_Renderer *_SDL_renderer;
SDL_Texture *_SDL_texture;
const unsigned char *_SDL_keyboardState;
int sdlEnd;
static inline void drawPixel(unsigned int x, unsigned int y, unsigned char color)
{
if (x < SCREEN_WIDTH && y < SCREEN_HEIGHT)
_SDL_screen[y * SCREEN_WIDTH + x] = color;
}
void sdlStep(void)
{
SDL_Event event;
SDL_UpdateTexture(_SDL_texture,NULL,_SDL_screen,SCREEN_WIDTH);
SDL_RenderClear(_SDL_renderer);
SDL_RenderCopy(_SDL_renderer,_SDL_texture,NULL,NULL);
SDL_RenderPresent(_SDL_renderer);
while (SDL_PollEvent(&event))
if (event.type == SDL_QUIT)
sdlEnd = 1;
SDL_Delay(10); // relieve CPU for 10 ms
}
void sdlInit(void)
{
SDL_Init(0);
_SDL_window = SDL_CreateWindow("program",SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,SCREEN_HEIGHT,SDL_WINDOW_SHOWN);
_SDL_renderer = SDL_CreateRenderer(_SDL_window,-1,0);
_SDL_texture = SDL_CreateTexture(_SDL_renderer,SDL_PIXELFORMAT_RGB332,
SDL_TEXTUREACCESS_STATIC,SCREEN_WIDTH,SCREEN_HEIGHT);
_SDL_keyboardState = SDL_GetKeyboardState(NULL);
SDL_PumpEvents();
}
void sdlDestroy(void)
{
SDL_DestroyTexture(_SDL_texture);
SDL_DestroyRenderer(_SDL_renderer);
SDL_DestroyWindow(_SDL_window);
}
int sdlKeyPressed(int key)
{
return _SDL_keyboardState[key];
}
void drawRectangle(int x, int y, int width, int height, unsigned char color)
{
for (int j = 0; j < height; ++j)
for (int i = 0; i < width; ++i)
drawPixel(x + i,y + j,color);
}
int main(void)
{
int playerX = SCREEN_WIDTH / 2, playerY = SCREEN_HEIGHT / 2;
sdlInit();
while (!sdlEnd) // main loop
{
sdlStep(); // redraws screen, refreshes keyboard etc.
drawRectangle(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,COLOR_WHITE);
drawRectangle(playerX - 10,playerY - 10,20,20,COLOR_RED); // draw player
// update player position:
if (sdlKeyPressed(SDL_SCANCODE_D))
playerX++;
else if (sdlKeyPressed(SDL_SCANCODE_A))
playerX--;
else if (sdlKeyPressed(SDL_SCANCODE_W))
playerY--;
else if (sdlKeyPressed(SDL_SCANCODE_S))
playerY++;
}
sdlDestroy();
return 0;
}
This program creates a window with a rectangle that can be moved with the WSAD keys. To compile it you first need to install the SDL2 library -- how to do this depends on your system (just look it up somewhere; on Debian like systems this will typically be done with sudo apt-get install libsdl2-dev), and then you also need to link SDL2 during compilation, e.g. like this: gcc -O3 -o graphics_sdl2 -lSDL2 graphics_sdl2.c.
This code is almost a bare minimum template for SDL that doesn't even perform any safety checks such as validating creation of each SDL object (which in real code SHOULD be present, here we left it out for better clarity). Despite this the code is quite long with a lot of boilerplate; that's because we need to initialize a lot of stuff, we have to create a graphical window, a texture to which we will draw, we have to tell SDL the format in which we'll represent our pixels, we also have to handle operating system events so that we get the key presses, to know when the window is closed and so on. Still in the end we are working with essentially the same functions, i.e. we have drawPixel (this time with pixel as a single char value because we are using the simple 332 format) and drawRectangle. This time sdlStep is the function that presents the drawn image on screen (it also does other things like handling the SDL events and pausing for a while to not heat up the CPU).
See also exercises.
We haven't nearly covered the whole of C, but you should be left with pretty solid basics now. Now you just have to go and write a lot of C programs, that's the only way to truly master C. WARNING: Do not start with an ambitious project such as a 3D game. You won't make it and you'll get demotivated. Start very simple (a Tetris clone perhaps?). Try to develop some consistent programming style/formatting -- see our LRS programming style you may adopt (it's better than trying to make your own really).
See also supplemental articles at the beginning of this tutorial.
You should definitely learn about common data structures (linked lists, binary trees, hash tables, ...) and algorithms (sorting, searching, ...). As an advanced programmer you should definitely know a bit about memory management. Also take a look at basic licensing. Another thing to learn is some version control system, preferably git, because this is how we manage bigger programs and how we collaborate on them. To start making graphical programs you should get familiar with some library such as SDL.
A great amount of experience can be gained by contributing to some existing project, collaboration really boosts your skill and knowledge of the language. This should only be done when you're at least intermediate. Firstly look up a nice project on some git hosting site, then take a look at the bug tracker and pick a bug or feature that's easy to fix or implement (low hanging fruit).
100% UNDER CONSTRUCTION
{ BEWARE: I am not a mathematician, this will be dumbed down for noobs and programmers like me, actual mathematicians may suffer brain damage reading this. ~drummyfish }
Calculus is a somewhat unpopular but immensely important area of advanced mathematics whose focus lies in study of continuous change: for example how quickly a function grows, how fast its growth "accelerates", in which direction a multidimensional function grows the fastest etc. This means in calculus we stop being preoccupied with actual immediate values and start focusing on their CHANGE: things like velocity, acceleration, slopes, gradients etc., in a highly generalized way. Calculus is one of the first disciplines one gets confronted with in higher math, i.e. when starting University, and for some reason it's a very feared subject among students to whom the name sounds like a curse, although the basics aren't more difficult than other areas of math (that's not to say it shouldn't be feared, just that other areas should be feared equally so). Although from high school textbooks it's easy to acquire the impression that all problems can be solved without calculus and that it will therefore be of little practical use, the opposite is in fact true: in real world EVERYTHING is about change, proof of which is the fact that in physics most important phenomena are described by differential equations, i.e. basically "calculus equations" -- it turns out that many things depend on rate of change of some variable rather than the variable's direct value: for example air friction depends on how fast we are moving (how quickly our position is changing), our ears hear thanks to CHANGE in air pressure, electric current gets generated by CHANGE of magnetic field etc. Calculus is very similar to (and sometimes is interchangeably used with) mathematical analysis (the difference is basically that analysis tries to prove what calculus does, at least according to the "Internet"). The word calculus is also sometimes used to signify any "system for making calculations", for example lambda calculus.
Is this of any importance to a programmer? Fucking YES, you can't avoid it. Consider physics engines, machine learning, smooth curves and surfaces in computer graphics, interpolation and animation, statistics, scientific simulations, electronics, robotics, signal processing and other kind of various shit all REQUIRE at least basics of calculus.
In essence there are two main parts to calculus, two mathematical "operations" that work with functions and are opposite to each other:
One thing shows here: one of the reasons why calculus is considered advanced is probably that instead of simple numbers we suddenly start working with whole functions, i.e. we have operators that we apply to function and we get new functions -- this requires some more abstract thinking as a function is harder to image than a number. But then again it's not anything too difficult, it just requires some preliminary study to get familiar with what a function actually is etc.
Now listen up, here comes the truth about calculus. Doing it correctly and precisely is difficult and sometimes literally impossible, and this is left for mathematicians. Programmers and engineers HAVE TO know the basic theory, but we are largely saved by one excellent thing: numerical methods. We can compute derivatives and integrals only approximately with algorithms that always work for any function and which will be good enough for almost everything we ever encounter in practice. Besides in digital computers we deal almost exclusively with non-continuous functions anyway, we just have very dense discrete sets of points because in the end we only have finite memory, integer values and sampled data, so there is nothing more natural than numerical methods here. So where a mathematician spends years trying to figure out how to precisely sum up infinitely many infinitely small parts of some weird function, we just write a program that sums up a very big number of very tiny parts and call it a day. Still there exist programs for so called symbolic computation that try to automatically do what the mathematician does, i.e. apply reasoning to get precise results, but these belong to some quite specialized areas.
xxx : ###
xx : ##
xx *** xxxxxxxxx
xx ***: ** xxx ##xxx
xx ** : *xx # xxx
xx ** : xx* # xx *
xx * :xx ** ## xxx x
xx * xx **## xxx xxx
x ** xx *# xxxxx*
x * xx: ##* *
xx * xx : ## ** *
xx * xx : ### * *
xxx * xxx : ## * *
xxxxxx ### ** *
----------------------*------####----------*--------------**----
########## : * *
* #### * : ** **
* ## ** : * **
* ## * : * *
** ## ** : * *
* ## * : *** **
* # ** : *****
** # * :
* # * :
## ** :
#** ** :
## ** * :
# ** ** :
Graph showing a function (x), its derivative (*) and (one of) its integral(s) (#).
The basics of calculus aren't that hard, however it can go deeper and deeper and one can probably dedicate whole life just to learning more and more; as you learn the basic derivatives and integrals, you move on to multidimensional calculus, vector calculus, integrating over curves and surfaces, various esoteric methods of analytical and numerical integration etcetc.
Calculus may also be considered advanced for the fact that -- historically speaking -- it's relatively "new", i.e. it took a long time to develop it and ancient and medieval civilizations existed without it despite otherwise having quite impressive math already. Of course precursors to calculus date very far back in history, parts of it and some special case problem were examined and solved, but it wasn't until 17th century when it was developed into a complete, general discipline. That happened thanks to Newton and Leibniz (they happened to develop it independently).
Derivative finds how quickly a function grows at any given point. DOING derivatives is called differentiation (confusingly because differential is a term distinct from derivative). Since derivative and integral are opposite operations, one would assume they'd be equally difficult to handle, but no, derivative is the easier part! So it's always taught first. It's kind of like multiplication and division -- multiplication is a bit easier (division has remainders, undefined division by zero etc.).
NOTE on notation: there are several notations used for derivatives. We will use a very simple one here: f'(x) to us is the derivative of a function f(x). Mathematicians will probably rather like to write d/dx f(x). Just know that this is a thing.
OK, BUT what exactly IS this "derivative"? What does it say? Basically derivative is the tangent to the graph of a function at given point. Derivative of function f(x) is a new function f'(x) which for given x says the slope of the graph of function f(x) at the point x. Slope here means literally the tangent function which encodes the angle at which the function is increasing (or decreasing). Tangent is defined as the (unitless) ratio of vertical change to horizontal change (for example if a plane is ascending with tangent equal to 2, we know that for every horizontal meter it gains two meters of height). Note that this is mathematically idealized so that no matter how quickly the function changes we really mean the slope at the exact single point, i.e. imagine drawing a tangent line to the graph of the function and then measuring how quickly it changes vertically versus how quickly it changes horizontally. Mathematicians define this using limits and infinitesimal intervals, but we don't have to care too much about that now, let's just assume it magically all works now.
Here it is shown graphically:
tangent / __
line / .' ''..
/ __.'f(x)
/-''
/|
__../:|dy
_-' /__|
/ dx
/ :
/ :
:
--------+--------------->x
A
Here we see a tangent line drawn at the graph of function f(x) at point A. We can draw the small right triangle and like shown -- the derivative at point A is now literally computed by dividing dy by dx. We can actually try to approximate the ideal derivative (and this is kind of how computers do it with the numerical methods) by computing (f(x + C) - f(x)) / C where C we set to some small number, for example 10^-10. It's basically how it's mathematically defined too, mathematicians just set the C to "infinitely small distance". By this notice that the derivative will be:
> 0 if the function is increasing. This is because dy will be positive and since dx is always positive, we'll get a positive number by dividing them.
< 0 if the function is decreasing. This is because dy will be negative and negative divided by positive dx is negative.Now it's important to say that derivatives can only be done with differentiable functions, i.e. ones that in fact DO have a derivative. This cyclic definition only says there indeed exist functions which are NOT differentiable -- imagine for example a function f(x) that gives 0 for every x except when x = 1 where f(1) = 1 -- what's slope of such function at x = 1? How the hell do you wanna integrate that? Firstly it's infinite (the tangent line goes completely vertically and here computing dy/dx just results in division by zero), but we don't even know if it's going up or down (it goes up from left but down to the right), it's just fucked up. Also a function that has holes (is not defined everywhere) clearly also isn't differentiable because if there's nothing to differentiate then what do you wanna do? A function that's not differentiable everywhere may still be differentiable in certain parts of course, but in general if we claim a function is differentiable we imply it's differentiable everywhere. It may also be the case that a function is differentiable but its derivative is not. Actually it further gets a bit more complicated, functions may also be partially differentiable, it is possible that a derivative may exist only from "one side", but we won't go into this. There exist conditions that must hold in order for a function to be differentiable, for example it must be continuous and maybe something else, just look that up if you need.
OK so to actually compute a derivative of a function we can use some of the following rules:
f(x) | f'(x) | comment |
|---|---|---|
n | 0 | additive const. |
x^n | n * x^(n-1) | var. to power |
e^x | e^x | |
sin(x) | cos(x) | |
cos(x) | -sin(x) | |
ln(x) | 1/x | for x > 0 |
a * g(x) | a * g'(x) | |
g(x) + h(x) | g'(x) + h'(x) | |
g(x) * h(x) | g'(x) * h(x) + g(x) * h'(x) | |
g(h(x)) | g'(h(x)) * h'(x) | chain rule |
Monkey example: we're about to find the derivative of this super retarded function:
`f(x) = x^2 - 2 * x + 3
Its graph looks like this:
:| :
3 + :
|: :
2 + '.._..'
|
1 +
|
--+----+----+----+--
-1 0| 1 2
|
To differentiate this function we only need to know (from the table above) that a derivative of a sum equals sum of derivatives and then just invoke a simple rule: derivative of x^N is N * x^(N-1). We have very little work to do here because there are no composed functions and similar shit, so we simply get:
`f'(x) = 2 * x - 2
So x^2 became 2 * x, -2 * x became just -2 (because x^0 = 1) and 3 just disappeared (this always happens to additive constants -- notice that such constants don't affect the function's slope in any way, so that's why). The graph of the derivative looks like this:
|
2 + /
| /
1 + /
| /
--+----+----+----+--
-1 0| /1 2
| /
-1+ /
|/
-2+
Things to notice here are:
x = 1, which means the function is monotonic at this point -- checking out the graph of the original function we see it really is so, the function turns there from decreasing to increasing.
x = 1 the derivative is negative, meaning the function is decreasing (checks out). The slope is also increasing gradually, meaning the function slows down in decreasing its value.
x = 1 the opposite is true: the slope is positive and starts increasing, i.e. the function starts increasing AND it keeps increasing faster and faster.
OK but what if we differentiate the derivative lol? This is legit, it will give us a higher order derivative and it is very useful and common. When we see the first derivative as the "speed" of the function's change, the second order derivative gives us the "speed" of the speed of function's change, i.e. basically it's acceleration. We will write second order derivative of function f(x) as f''(x). This can for example tell us where the function is convex versus concave (how it is "bent"), which again helps with finding minimum and maximum values etc. Of course we may continue and make third order derivative, fourth etc.
Next we must mention partial derivatives which are basically multidimensional derivatives, i.e. ones we do with functions of multiple variables. There is one important thing to mention: when differentiating a function of multiple variables, we have to say which variable we are differentiating against, which is an equivalent of choosing the axis along which we differentiate. Practically this will result in us treating the non-chosen variables as if they were constants. So say we have a function of two variables f(x,y): we can differentiate it against the variable x and also y, i.e. we get two different derivatives. If we imagine the function f(x,y) as a two dimensional heightmap, then the derivative against x means we are getting a slope as if we're going in the x axis direction (and accordingly the same holds for y). This is why it's called partial derivatives: there are multiple derivatives, multiple parts. Making a vector out of all partial derivatives will give us a gradient which is kind of an "arrow" that can tell us in which direction the increase/decrease if the fastest. This is very important for example for machine learning where we are trying to minimize the error function by following the path of the gradient etc. All this is beyond the scope of this article though.
Integral is the opposite to derivative. There are usually two main ways to interpret what an integral means:
Both of these interpretations are equivalent in that we will compute the same thing, they only differ in how we think of what we are computing.
As already claimed in the section on derivative, integrating is more difficult than differentiation. Some reasons for this are:
f(x) = x and f(x) = x + 1 will both have the same derivative) -- so when we're integrating we always get function that has a variable additive constant in it.
sin(x)/x).So due to these complications we now yet have to explain the two different types of integrals:
f(x) = 1 will be x + C. In practice the result we are searching is often a definite integral (a single value), but to compute that we have to start by computing the indefinite integral. However it's also very hard to calculate indefinite integrals -- they are the precise solution and holy grail of integration but in practice we can't always get them and have to resort to approximations.
f(x) = 1 over interval [0,1] will give us 1 (imagine the graph: the area is simply that of a square with side 1). Definite integrals are computed from the indefinite integral by plugging the upper interval number into the indefinite integral (in the place of the variable), then plugging the lower interval number, and then subtracting the latter from the former. With numeric methods (computer integration) we always only get definite integrals (and actually only their approximate values) -- the computer here skips computing the indefinite integral (as that's hard) and rather like a dull machine LITERALLY goes by small steps and computes the area below the function graph. Small note to this: the computer still can draw a graph of a function's integral by plotting definite integral value for interval 0 to x for every plotted x because when we think about it, the indefinite integral kind of gives us a function of how an indefinite integral grows; so the computer can give us a picture of a graph but it generally cannot give us an analytically computed formula of indefinite integral.Fun fact: before digital computers engineers used very clever methods to find definite integrals of general functions. Analog computers were particularly good at integrating, their continuous nature makes them a quite elegant solution to the problem, however perhaps even more genius method in its simplicity was the following: the engineer would draw the function he wanted to integrate on a sheet of paper (or maybe more preferably some kind of heavier material), then cut it out and simply weight its mass -- this would give him the fraction of the weight of the whole sheet of paper and so also the fraction of the area below the function graph.
Example: we will now try to make an indefinite integral of the function:
`f(x) = 2 * x - 2
This is the derivative we got in the example of differentiation, so by integrating we should get back the original function we differentiated there.
Now for the notation: the symbol for integral is kind of a big italic S (Unicode U+222), but for simplicity we will just use the uppercase letter I here. With indefinite integrals only the symbol alone is used. For definite integrals we additionally write the interval over which we make the integral, i.e. I(A,B) (normally A is written at the bottom and B at the top), where A and B says the interval. So we will now write our indefinite integral like this:
`I (2 * x - 2) dx
Wait dude WHAT THE FUCK is this dx shit at the end? This question is expected. Look: it has to do with the theory behind what the integral mathematically means, for starters one can just ignore it and remember that integral starts with I, then the integrated function follows, and then there is dx at the end. But to give a bit of explanation: firstly notice the dx tells us what the integrated variable is -- usually we have a function with single variable x and so it's pretty clear, but once we move to more dimensions we'll have more variables and this dx tells us what is a variable (i.e. along which axis we are integrating) and what is to be treated as a constant (maybe this doesn't yet make much sense but with integration there is a big difference between a variable and a constant, even if they are both represented by a letter). The real reason for dx is that the integral really represents an infinite sum. Have you ever seen that big sigma symbol for a sum? The integral symbol (here I) is like this, it likewise says "make an infinite sum of what will follow". But if we take a function and make infinitely many steps and keep summing the values the function gives us, we will just get infinity as the sum, so something is missing. In fact we don't want to sum the function values but rather areas of "tiny strips" we are kind of drawing below the function graph -- now a strip is basically a rectangle: area of a rectangle is computed as its height times its width. Height of the rectangle is the function value (here 2 * x - 2) and width is dx, which represents the "infinitely narrow" interval. This is just to give some idea about WHY it looks like this, but it's cool to ignore it for now.
So now the fuck we can finally move on. Our integral is really easy because it's just a sum of two expressions (and an integral of a sum thankfully equals a sum of integrals) that can be integrated easily. So from the rule I x^N dx = x^(N + 1) / (N + 1) we deduce that integral of 2 * x is 2 * x^2 / 2 = x^2 and integral of -2 is -2 * x, so we get:
`I (2 * x - 2) dx = x^2 - 2 * x + C
A few things to note here now:
C = 0, then we'll get a function x^2 - 2 * x, and if we differentiate this back, we'll get the function we integrated: 2 * x - 2. But we will also get the same function no matter what C we set because, like explained in the derivative section, additive constants disappear in differentiation. So just never forget this constant. We didn't obtain a single function but an infinite set of functions that differ just by the value of C (i.e. their graphs are just vertically shifted).
x^2 - 2 * x + 3, which confirms our result as correct. Or, as per above, we should rather say again that this function is a part of the set of functions we computed, one with C = 3.Our example integral wasn't that hard, right? Yes, this was extremely easy, but once you start integrating something with composed functions (functions inside other functions) you'll get into all sorts of trouble.
Now let's finish with computing a definite integral, OK? Let's say we want to compute the integral over interval 0 to 1, i.e. we'll write:
`I(0,1) (2 * x - 2) dx
Above we said this is done by computing indefinite integral (already done), then plugging the upper and lower bound and subtracting, so let's do it:
`I(0,1) (2 * x - 2) dx = (1^2 - 2 * 1 + C) - (0^2 - 2 * 0 + C) = -1
Things to notice here:
2 * x - 2 up above and pay attention to the interval 0 to 1. The function's value is below zero and we said that area below zero will be negative, so this checks out. Also we can see that geometrically the size of the area is a half of a rectangle of height 2 and width 1, which is exactly 1. So all in all we're cool.For completeness here are some rules for integration:
f(x) | I f(x) dx | comment |
|---|---|---|
a * x^n | a * (x^(n+1))/(n+1) + C | |
cos(x) | sin(x) + C | |
sin(x) | -cos(x) + C | |
e^x | e^x + C | |
1/x | log(x) + C | |
a * g(x) + b * h(x) | a * (I g(x) dx) + b * (I h(x) dx) + C | |
g(x) * h(x) | g(x) * (I h(x) dx) - (I g'(x) * (I h(x) dx) dx) + C | per partes |
However note that applying these rules is generally not so simple as with differentiation, there exist methods such as per partes or substitution that don't tell you exactly how or when to apply them, so you have to experiment -- like said, this is an entertainment left to those who just enjoy doing math.
Can we do higher order integrals and partial integrals? Yes, of course, just like with derivatives we can do both of these.
Here is a small C code that produces the image at the top showing a graph of a function, its derivative and integral. Please keep in mind this is the most naive example using the simplest algorithm that in practice would be too inaccurate and/or inefficient, but it's good for demonstration. For shorter code we resort to using floating point but of course we can always avoid it with fixed point. You can try to play around with the function and see how its derivative and integral changes. Note that the plotted integral is indeed just one of the infinitely many integrals that would be differently vertically shifted by the constant C -- here we just plot the one that at x = 0 goes through 0.
#include <stdio.h>
#include <math.h>
#define GRAPH_RESX 64 // ASCII graph resolution
#define GRAPH_RESY 28
#define GRAPH_SIZE 2.5 // interval shown in the graph
#define DX 0.01 // for numeric methods
double f(double x) // our function
{
return 1 + sin(2 * x) + 0.2 * x * x;
}
double derivative(double (*f)(double), double x)
{
return (f(x + DX) - f(x)) / DX;
}
double integral(double (*f)(double), double x)
{
int steps = x / DX;
double r = 0;
int flip = x < 0;
if (x < 0)
steps *= -1;
else
x = 0;
while (steps)
{
r += f(x) * DX;
steps--;
x += DX;
}
return flip ? -1 * r : r;
}
char graphImage[GRAPH_RESX * GRAPH_RESY];
void graphDraw(double x, double y, char c)
{
int drawX = ((x + GRAPH_SIZE) / (2 * GRAPH_SIZE)) * GRAPH_RESX,
drawY = GRAPH_RESY - ((y + GRAPH_SIZE) / (2 * GRAPH_SIZE)) * GRAPH_RESY;
if (drawX >= 0 && drawX < GRAPH_RESX && drawY >= 0 && drawY < GRAPH_RESY)
graphImage[drawY * GRAPH_RESX + drawX] = c;
}
int main(void)
{
// clear the graph image:
for (int i = 0; i < GRAPH_RESX * GRAPH_RESY; ++i)
graphImage[i] = (i % GRAPH_RESX) == GRAPH_RESX / 2 ? ':' :
((i / GRAPH_RESX) == GRAPH_RESY / 2 ? '-' : ' ');
// now plot the function, its derivative and integral
for (double x = -1 * GRAPH_SIZE; x < GRAPH_SIZE;
x += GRAPH_SIZE / (2 * GRAPH_RESX))
{
graphDraw(x,integral(f,x),'#');
graphDraw(x,derivative(f,x),'*');
graphDraw(x,f(x),'x');
}
// draw the graph:
for (int i = 0; i < GRAPH_RESX * GRAPH_RESY; ++i)
{
putchar(graphImage[i]);
if ((i + 1) % GRAPH_RESX == 0)
putchar('\n');
}
return 0;
}
Capitalism is how you enslave a man with his approval.
Capitali$m is the worst socioeconomic and sociopathic system we've yet seen in history,^source based on pure greed ("greed is good" being one of the fundamental capitalist mottos), 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 and suffer for basic resources, even in a world where abundance of resources is already possible to be achieved -- 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, ...), utilization and perfection of torture methods, 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 stopping an ever accelerating growth. Nevertheless, Fredric Jameson aptly stated (in Capitalist Realism: Is There No Alternative?, 2009) that "it's easier to imagine the end of the world than the end of capitalism". Capitalism will be there long after humans are gone. 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 is, indeed, a truthful description.
{ 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 (and eventually gain enough power to even become the arbiters of "fairness" of the competition, i.e. they seize absolute power) -- 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, establishing thought shortcuts 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 degree. 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. It's odd that the public gets fanatically enraged once a politician shows even a slight hint on conflict of interest while no one seems to mind that we choose to let conflict of interests be the most fundamental principle of our society, to the degree that we get anxious if there's not enough of it. Idiots such as Adam Smith try to "justify" this by being descriptive and prescriptive at the same time: he claims that "the butcher provides others with meat from the motive of his own benefit" and he is not even wrong because he's just describing status quo without offering any idea for improvement; however if someone comes forth with an actual suggestions for improvement of society, he starts shitting his pants and yelling like a small baby that status quo must stay in place BECAUSE status quo is how he described it (i.e. it's a shitty circular argument that makes no sense but what do you expect from a retard?). And so supporting competition makes no sense, it's merely what's been in place and for that sole reason we decided to support it, like when a patient comes to the doctor with a disease and the doctor says "yes, you have a disease, so you need more of it". This is further combined with the fact that the environment of free market is an evolutionary system which by the process of natural selection extremely effectively and quickly optimizes organisms (corporations) to be best suited for 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 by now a good few years have already gone by since the times of Marx/Engels and capitalism has meanwhile reached yet a next level stage with countless disastrous issues Marx couldn't even have foreseen, it is useful to remind ourselves of one of the basic and earliest features 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 essentially 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.
capitalism = LRS =
worst practically best practically
possible society possible society
| |
| |
dystopia V V utopia
competition, tyranny, <------|------------------------|------> love, peace, equality,
slavery, exploitation, \ / \ / collaboration, abundance,
hierarchy, war, ... \ / \ / freedom, sharing, ...
\/ \/
so bad it so perfect
can't practically it can't practically
keep functioning be achieved
Capitalism on utopia-dystopia spectrum: while a good society tries to come as close as possible to the ideal utopia, capitalism starts with the idea of a dystopia (conflicts, exploitation, suffering as motivation, ...) and tries to just make it barely livable, always staying just shy of dystopia so bad it couldn't practically work (e.g. putting too much pressure on workers so as to kill them all).
Who invented capitalism? Well, it largely developed on its own, society is just responsible for not having stopped 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 ruled by noblemen, poor by rich etc.), combined with technological progress (or more correctly "degradation") 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 }
Proceeding with the valid analogy between capitalism and cancer, we find 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 the cells before they start to grow uncontrollably, as has been happening in our society. In the past we used to posses this kind of immunity too, it was the people themselves who would amass and revolt whenever capitalist pressure went too far -- this has amounted for a great deal of revolutions in history. The capitalism of today however already represents a malignant tumor as we're most likely beyond the point of capitalist singularity, i.e. society with a tumor that was failed to be removed at an early stage (we instead decided to feed it), the matter got out of hand and can no longer be fixed now, the defensive mechanism such as revolutions are already prevented by capitalism itself, all communication is completely controlled and any revolutionary spark smothered on the spot, thinking of people is under control too, manipulated at will of corporations and even if a crowd by a small miracle did indeed revolt, today's military and police force is so powerful that none can hope to stand a chance.
In capitalism only idiots survive because idiots 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 problems seen in 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 replace them 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 developed 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. Also the 1985 movie Brazil is excellent. ~drummyfish }
A capitalist often throws around would be arguments that will not stand up to scrutiny. One of them is for example that a factory owner's salary is higher that the factory worker's because his "responsibility" is higher. I.e. Elon Musk makes 500000 times more than an average American because he allegedly carries 500000 times heavier burden of responsibility -- but what hides beyond the word "responsibility" here? Does it mean that if Elon makes the same kind of mistake as factory worker, he'll be punishes 500000 times more severely? If a factory worker drinks and fails to show up at work, he'll get fired, so if Elon doesn't show up at work one day, what punishment is 500000 worse? It would had to mean at least being stripped of all his money and property, someone could even say it could be a death sentence -- however do you think anything close to this is ever going to happen? Notwithstanding this "grand responsibility" and constant reports of billion dollar frauds, the rich seem to actually be the least likely to even physically end up in jail. In fact the worst punishment that ever realistically happens to the rich is being forced out of the big game and that's it, they never go to jail or even end up much poorer. So somehow this doesn't add up. And now the capitalist says "oh no, the weight of responsibility is not measured by consequences, it's more of a moral weight of FEELING responsibility for so many people he employs". Okay, firstly this seems to imply that the richest are highly moral people with strong sense of conscience and totally not psychopaths, which, frankly, must today sounds laughable to anyone, but alright. If it was so -- if the punishment for failure should be purely moral -- why then isn't the reward for success also purely moral? I.e. no higher salary, just a good feeling. And to this the capitalist finally has no answer, and he'll start to throw around other nonsensical phrases that keep shifting the goal post like "look, this is a jungle, I just act accordingly" (so now all the noble moral values he spoke about are somehow out), "it's not a perfect system, but the only one that works" (Really? Take a look around.), "if you don't want to be rich, your problem" (Is this even an argument anymore?), and so on, at which point the debate degenerates to the proverbial "playing chess with a pigeon".
Capitalists themselves are soulless, empty shells incapable of truthful human emotion, the lowest subhuman scum, a pinnacle of evolutionary degeneracy, born only to seek own pleasure while even having the audacity to call it "doing good", they're masters of pretense and stupidity, manipulation and lie, and lack capability to think about anything but how to best reach yet more and more pleasure, luxury and overeating, and this constant preoccupation with this single primitive goal makes them in fact perfect it and pursue it for any price, they're dangerous by possessing human level of reasoning and looking like humans while lacking any human feelings except for endless greed. Capitalist's aim is only to manipulate, exploit and abuse and so his goal will always be that people find no peace, no comfort or rest, he has to ensure people are constantly bothered by something and pushed, forced to be caught in his nets. In a world where capitalism persists it is impossible to ever achieve calm and peaceful society.
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.
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 brutally difficult 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, like in any race late starters are always disadvantaged. So this advice is similar to telling someone to "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 frantic 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 follows 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 cellular organisms. The system will be less and less beneficial to people who will only serve as cells to the superorganism, becoming its slaves. A cell isn't supposed to be happy, it's expected to sacrifice its life for the good of such superorganism.
{ 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 playing but a small role in the company's grandiose plan, and so no one feels responsible for the whole or sometimes doesn't even know (or pretends not to know) what he's part taking in. Division of labor has been expanded to division of responsibility, the unbearable weight of unethical behavior is spread among many so it becomes bearable -- as someone once pointed out, big organizations always utilize this practice: "clean hands for the mastermind, clean conscience for the executor". If anyone happens to protest, he's replaced with a new hire, and so people aren't even tempted to protest ("if not me, someone else would have done it"). 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 to 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 gained absolute control over the people at this point, they'll be 100% dependent on the system even if they hate it, apathetic by constant tiresome tyranny, 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 happenstance 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 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:
At this point basically anything else is better. But we here advocate less retarded society.
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).
UPDATE: There is now a similar waiver called WPDD (worldwide public domain dedication, https://wpdd.info/), intended to also waive patents.
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, Lichess chess 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 (EDIT: seems like they dropped it now :D Internet archive has the old CC0 version still), 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.
Chess (from Persian shah, king) is a very old two-player board game, perhaps most famous and popular among all board games in history. To the common folk familiar with video games it could be described as a turn-based strategy, in mathematical terms it's a zero sum, complete information game with no element of randomness, that simulates a battle of two armies on an 8x8 board with different battle pieces, also called chessmen or just men (also stones, pieces or juicers). Chess is also called the King's Game, it has a worldwide competitive scene and is considered an intellectual sport but it's also been a subject of rigorous research and programming (countless chess engines, AIs and frontends are being actively developed). Chess is similar to games such as shogi ("Japanese chess"), xiangqi ("Chinese chess") and checkers. As the estimated number of chess games is bigger than googol, it is unlikely to ever get solved; though the complexity of the game in sheer number of possibilities is astronomical, among its shogi, go and xiangqi cousins chess is actually considered one of the "simplest" (the board is relatively small and the game tends to simplify as it goes on as there are no rules to get men back to the game etc.). In 2020s the game received more mainstream attention and popularity, which under capitalism means a disaster, influx of toxicity and SJWs, commercialization, "chess platforms" full of ads and microrape, retarded influencers, women, furries, trannies, anticheating malware, idiotic propaganda movies and much more -- this crap is to be avoided. It has to be especially stressed that chess is NOT an "esport".
{ There is a nice black and white indie movie called Computer Chess about chess programmers of the 1980s, it's pretty good, very oldschool, starring real programmers and chess players, check it out. ~drummyfish }
Drummyfish has created a suckless/LRS chess library smallchesslib which includes a simple engine called smolchess (and also a small chess game in SAF with said library) -- it is very weak but may be fun to play around with :)
At LRS we consider chess to be one of the best games for the following reasons:
Chess is a marvelous game but not a perfect one, many still perceive go as the supreme king of board games, yet more beautiful, both more minimal and more difficult to master, with playing experience unlike any other. Thankfully there is no need to choose one or the other -- why not play both? :)
Where to play chess online? It won't come as a surprise that many chess servers exist, such as https://chess.com or https://chess24.com -- however these ones are proprietary, shitty, cancerous and unusable, NEVER touch them. { The cocsuckers from chess.com just started to hardcore spam my mail when I registered there lol. ~drummyfish } A much better one is Lichess (libre chess) at https://lichess.org which is not only FOSS, but also gratis, without ads and is actually superior in all ways even to the proprietary sites, allowing users to run their own bots, offering public domain database of all the games and positions, API, analysis board, puzzles, chess variants, minigames, TV and much more -- however it requires JavaScript. Another server, a more suckless one, is Free Internet Chess Server (FICS) at https://www.freechess.org/ -- on this one you can play through telnet (telnet freechess.org 5000) or with graphical clients like pychess. Online servers usually rate players with Elo/Glicko just like FIDE, sometimes there are computer opponents available, chess puzzles, variants, analysis tools etc.
Chess as a game is not and cannot be copyrighted, but can chess games (moves played in a match) be copyrighted? Thankfully there is a pretty strong consensus and precedence that say this is not the case, even though capital worshippers try to play the intellectual property card from time to time (e.g. 2016 tournament organizers tried to stop chess websites from broadcasting the match moves under "trade secret protection", unsuccessfully).
Chess and IQ/intelligence (a quite comprehensive summary of the topic is available here: http://www.billwallchess.com/articles/IQ.htm): there is a debate about how much of a weight general vs specialized intelligence, IQ, memory and pure practice have in becoming good at chess. It's not clear at all, everyone's opinion differs. A popular formula (Levitt equation) states that highest achievable Elo = 1000 + 10 * IQ, though its accuracy and validity are of course highly questionable. All in all this is probably very similar to language learning: obviously some kind of intelligence/talent is needed to excel, however chess is extremely similar to any other sport in that putting HUGE amounts of time and effort into practice (preferably from young age) is what really makes you good -- without practice even the biggest genius in the world will be easily beaten by a casual chess amateur, and even a relatively dumb man can learn chess very well under the right conditions (just like any dumbass can learn at least one language well); many highest level chess players admit they sucked at math and hated it. As one starts playing chess, he seems to more and more discover that it's really all about studying and practice more than anything else, at least up until the highest master levels where the genius gifts a player the tiny nudge needed for the win -- at the grandmaster level intelligence seems to start to matter more. Intelligence is perhaps more of an accelerator of learning, not any hard limit on what can be achieved, however also just having fun and liking chess (which may be just given by upbringing etc.) may have similar accelerating effects on learning. Really the very basics can be learned by literally ANYONE, then it's just about learning TONS of concepts and principles (and automatize them), be it tactical patterns (forks, pins, double check, discovery checks, sacrifices, deflections, smothered mates, ...), good habits, positional principles (pawn structure, king safety, square control, piece activity, ...), opening theory (this alone takes many years and can never end), endgame and mating patterns, time management etcetc.
{ NOTE (speculative): I think I've heard some research suggested that it's not so much the spatial/visual part of the brain that's responsible for playing chess but rather the language part, it really seems like learning chess might be more similar to learning a foreign language -- it takes about the same time to become "fluent" at chess and the key to being good at it is starting at young age. I.e. the relationship of chess and intelligence is probably similar to that of language learning and intelligence. ~drummyfish }
Fun historical fact: chess used to be played over telegraph, first such game took place probably in 1844.
Fun fact 2: in 2022 a chess playing robot took and broke a finger of a 7 year old opponent lol.
How to play chess with yourself? Should you lack a computer or humans to play against, you may try playing against yourself, however playing a single game against oneself doesn't really work, you know what the opponent is trying to do -- not that it's not interesting, but it's more of a search for general strategies in specific situations rather than actually playing a game. One way around this could be to play many games at once (you can use multiple boards but also just noting the positions on paper as you probably won't be able to set up 100 boards); every day you can make one move in some selected games -- randomize the order and games you play e.g. with dice rolls. The number of games along with the randomized order should make it difficult for you to remember what the opponent (you) was thinking on his turn. Of course you can record the games by noting the moves, but you may want to cover the moves (in which case you'll have to be keeping the whole positions noted) until the game is finished, so that you can't cheat by looking at the game history while playing. If this method doesn't work for you because you can keep up with all the games, at least you know you got real good at chess :) { This is an idea I haven't tried yet, I'm leaving it here as a note, will probably try it one day. ~drummyfish } Also check out single player chess variants.
Is there any luck or randomness in chess? Not in the rules itself of course, there are no dice and hidden information, but still luck and randomness is present in the meta game (playing as white vs black may be decided randomly, your opponent may be assigned to you randomly etc.) and then de facto in the fact that although no information is hidden, no one can ever have a complete information due to the sheer complexity of the game, so in practice playing chess involves risk, intuition and educated guessing at any human and superhuman (computer) level. So chess players do commonly talk about luck, outcome of a game is always a matter of probability which is however given by the relative skill of both players. Computer chess engines evaluate positions probabilistically, i.e. telling the probability of white versus black winning, even though in theory a perfect play from any given position has a strictly determined outcome: win, loss or draw. So not even best computers can consider chess completely determined. In human play probability of a hobbyist beating professional in a fair game, unlike e.g. in some card games, can effectively be considered zero, which indeed proves chance plays a minimal role.
Chess evolved from ancient board games in India (most notably Chaturanga) in about 6th century -- some sources claim that the game's predecessors used dice to determine which man a player was allowed to move but that this element of randomness had to be removed as dictated by anti-gambling laws. Nowadays the game is internationally governed by FIDE which has taken on the role of an authority defining the official rules: FIDE rules are considered to be the standard rules of the game. FIDE also organizes tournaments, promotes the game and keeps a list of registered players whose performance it rates with so called Elo system -- based on the performance it also grants titles such as Grandmaster (GM, strongest, around 2000 in the world), International Master (IM, second strongest, roughly 4000 in the world), FIDE Master (FM, roughly 8000 in the world) or Candidate Master (CM). In chess you are basically your rating. The game of chess is so entertaining on its own that it doesn't need to be spiced by money and bets, like so many other games (poker, backgammon, ...).
Chess skill is often divided into two broad areas (it is also common to divide strong players into these two categories depending on where their main strength lies):
Of course this is not the only possible division, another one may be for example offensive vs defensive play etc., but generally chess revolves around position and tactics.
A single game of chess is seen as consisting of three stages: opening (starting, theoretical "book" moves, developing men), middlegame (seen as the pure core of the game) and endgame (ending in which only relatively few men remain on the board, sometimes also defined as play without queens). There is no clear border between these stages and at times they are defined differently, however each stage plays a bit differently and may require different skills and strategies; for instance in the endgame kings become active while in the opening and middlegame they try to stay hidden and safe.
The study of chess openings is called opening theory or just theory. The opening stage is distinct by being based on memorization of this theory, i.e. hundreds and thousands of existing opening lines that have been studied and analyzed by computers, rather than by performing mental calculation (logical "thinking ahead" present in middlegame and endgame) and creativity. Many now see opening theory as the ugly, harmful part of chess, one forcing players to spending energy on pure memorization of opening lines. One of the chess legends, Bobby Fischer, held this opinion strongly and devised a chess variant with randomized starting positions so as to do away with this memorization -- the variant is called chess 960 (also Fischer random or freestyle chess).
Elo rating is a mathematical system of numerically rating the performance of players (apart from chess also used in many other sports); Elo essentially assigns players a rating number that expresses the player's skill. Given two players with Elo rating it is possible to compute the probability of the game's outcome (e.g. white has 70% chance of winning etc.). The FIDE set the parameters so that the rating is roughly this: < 1000: beginner, 1000-2000: intermediate, 2000-3000: master (currently best humans rate close to 3000). More advanced systems have also been created, namely the Glicko system, however these are often quite bloated and complicated, so Elo stays the most commonly used rating system. Alternative ways of determining player skills also exist, for example so called accuracy, which says how closely one played to the perfect play according to some strong engine such as stockfish. The advantage here is that to rate a player we don't need too much data like with Elo (which needs to see many games of the player against other already rated players) -- it may be enough to let the player play a few games against a computer to determine his skill. A disadvantage however lies in how exactly to compute accuracy because that gets a little complicated by other factors, for example many times finding the best move is trivial (like retaking a queen in an exchange) while in others gets much more difficult, or the fact that humans often DON'T want to play the mathematically best move but rather a bit weaker, more comfortable one, so even grandmasters often choose a weaker move even though they know the theoretically best move. Another idea may be to use a standard set of puzzles, basically like an IQ test. Yet another idea is for example to compute so called Erdos number, i.e. the minimum length of a chain of victories from the world's best player, i.e. for example rating player A with number 3 says he defeated someone who defeated someone who defeated the world's best. A guy called tom7 devised a method for measuring performance of weak chess engines by basically mixing stockfish (the strongest chess engine) with a random move bot in certain ratios -- i.e. making an engine that with certain probability (given by the mixture ratio) plays either a move by stockfish or a random move -- and then determining the mixture ratio at which this monstrosity becomes indistinguishable from the tested engine (i.e. we can say "the tested engine is a mixture of stockfish and random moves in this ratio"). Along these lines we may similarly try to compute how much of a different kind of handicap -- let's say material or time (or, with humans, amount of alcohol) -- we have to give to the strong engine for it to become on par with the tested entity (i.e. the ratio of wins and losses is about 1).
The rules of chess are fairly simple (easy to learn, hard to master) and can be found anywhere on the Internet. In short, the game is played on a 8x8 board by two players: one with white men, one with black (LOL IT'S RACIST :D). Each man has a way of moving and capturing (eliminating) enemy men, for example bishops move diagonally while pawns move one square forward and take diagonally. The objective is to checkmate the opponent's king, i.e. put the king under attack while leaving him no way of escape. There are also lesser known rules that noobs often miss and ignore, e.g. so called en-passant or the 50 move rule that declares a draw should there occur no "significant" move for 50 consecutive turns.
At the competitive level clock (so called time control) is present to impose a time limit on making moves: with unlimited move time games would be painfully long and more of a test of patience rather than skill. Clock can also conveniently help balance unequal opponents by reducing the stronger player's thinking time. Based on the amount of time to move we recognize several game formats, most notably correspondence (slowest, days for a move), classical (slow, hours per game), rapid (faster, tens of minutes per game), blitz (fast, a few seconds per move) and bullet (fastest, units of seconds per move). Most frequently each player is given a total time for making all his moves plus a so called increment, a small time amount added back after every move. There is also a category called cyborg or centaur chess in which computer assistance is allowed (which would normally be seen as cheating) -- this category usually greatly overlaps with correspondence chess.
Currently the best player in the world -- and by now almost undeniably the best player of all time -- is very convincingly Magnus Carlsen (born 1990), a white man from Norway with Elo rating 2800+. On most days he habitually wipes the floor with all the other top players effortlessly, he was winning the world championship over and over before giving up the title out of boredom.
During the covid pandemic (circa 2020) chess has experienced a small boom among normies and YouTube chess channels have gained considerable popularity. This boosted chess as such and gave rise to memes such as the bong cloud opening popularized by a top player and streamer Hikaru Nakamura; the bong cloud is an intentionally shitty opening that's supposed to taunt the opponent (it's been even played in serious tournaments lol).
White is generally seen as having a slight advantage over black (just like in real life lol). This is because he always has the first move -- statistics confirm the claim as white on average wins a little more often (even in the world of computers which is spared of psychological factors). The advantage is very small, estimated by engines to be around a very small fraction of a pawn, and this slight imbalance doesn't play such as big role in beginner and intermediate games but starts to become apparent in master games where the play can be very equal. How big the advantages is exactly is a matter of ongoing debate, most people are of the opinion there exists a small advantage for the white (with imperfect, human play, i.e. that white plays easier, has more choices, tolerates slightly less accurate play), though most experts think chess is a draw with perfect play (pro players can usually quite safely play for a draw and secure it if they don't intend to win; world championships mostly consist of drawn games as really one player has to make a mistake to allow the other one to win). Minority of experts think white has theoretical forced win. Probably only very tiny minority of people think white doesn't have any advantage or even that black is in a better overall position. Some argue that even if black doesn't have an overall advantage, he still has a number of smaller advantages over white, as it's true that sometimes the obligation to make a move may be a disadvantage (this is called zugzwang). It's for example true that the theoretical fastest possible checkmate is delivered by black, not white. Probably no one thinks black has a forced win though, but as that's not disproved yet so maybe someone actually believes it.
Blindfold play: it's quite impressive that very good players can play completely blindfold, without any actual chessboard, and some can even play many games simultaneously this way. This is indeed not easy to do and playing blindfold naturally decreases one's strength a bit (it seems this is more of a case on lower level of play though). It is however not the case that only an exceptional genius could play this way, probably anyone can learn it, it's just a matter of training (it's a matter of developing an efficient mental representation of the board rather than actually exactly remembering the whole board -- in psychology called chunking). Probably all masters (above FIDE ELO 2000) can play blindfold. They say the ability comes naturally just by playing countless games. How to learn playing blindfold then? Just play a lot of chess, it will come naturally -- this is the advice probably most often given. However if you specifically long with your whole heart to just learn blindfold play as a cool party trick, you may focus on it, e.g. by training blindfold against a very weak computer { Smolchess is IDEAL for this :] ~drummyfish }. Some software chess boards offer a mode in which one can see the position and color of all men but not which type they are -- this may perhaps be a good start. It may possibly also be done very gradually -- for example start by covering just part of the board and every week cover yet more squares; eventually you'll have them all covered.
On perfect play: as stated, chess is unlikely to be ever solved so it is unknown if chess is a theoretical forced draw or forced win for white (or even win for black), however many simplified endgames and some simpler chess variants have already been solved. Even if chess was ever solved, it is important to realize one thing: perfect play may be unsuitable for humans and so even if chess was ever solved, it might have no significant effect on the game played by humans. Imagine the following: we have a chess position in which we are deciding between move A and move B. We know that playing A leads to a very good position in which white has great advantage and easy play (many obvious good moves), however if black plays perfectly he can secure a draw here. We also know that if we play B and then play perfectly for the next 100 moves, we will win with mathematical certainty, but if we make just one incorrect move during those 100 moves, we will get to a decisively losing position. While computer will play move B here because it is sure it can play perfectly, it is probably better to play A for human because human is very likely to make mistakes (even a master). For this reason humans may willingly choose to play mathematically worse moves -- it is because a slightly worse move may lead to a safer and more comfortable play for a human. This fact has also recently been demonstrated by a modified Leela engine that specifically focuses on handicapped play (playing without one knight or rook) against humans -- even though Stockfish is objectively a better engine than Leela, this specific Leela version achieves better results under stated conditions, i.e. it more often beats human grandmasters in odds games, and that's because it learned to play moves that are not objectively methematically best, but rather best AGAINST HUMANS, i.e. creating confusion, tension, tricky and unusual situations and psychological pressure that favor precise engines.
Effects of alcohol on chess skill: they're most likely negative, but HOW much exactly hasn't been rigorously examined yet, so this is a great topic for potential research: if you're a chess player, it is recommended you perform these experiments and make the results public: grab some beers or vodkas and measure your performance as a function of alcohol in blood or at least amount of alcohol drunk (along with you sex, race and weight). So far informal talk on the internet suggests that being moderately drunk decreases ELO by around 200. Other drugs may be interesting too.
Fun fact: there seem to be almost no black people in chess :D the strongest one seems to be Pontus Carlsson which rates number 1618 in the world; even women seem to be much better at chess than black people. This website says that as of 2015 there were only 3 black grandmasters in the whole world. But how about black women? LMAO, it seems like there haven't even been any black female masters :'D The web is BLURRY on these facts, but there seems to be a huge excitement about one black female, called Rochelle Ballantyne, who at nearly 30 years old has been sweating for a decade to reach the lowest master rank (the one which the nasty oppressive white boys get at like 10 years old) and MAYBE SHE'LL DO IT, she seems to have with all her effort and support of the whole Earth overcome the 2000 rating, something that thousands of amateurs on the net just causally do every day without even trying too much. But of course, it's cause of the white male oppression =3 lel { anti-disclaimer :D Let's be reminded we love all people, no matter skin color or gender. We are simply stating facts about nature, which don't always respect political correctness. ~drummyfish } EDIT: We seem to have missed Tuduetso Sabure who became a WOMAN grandmaster (i.e. NOT a regular grandmaster) in 2005, however her peak rating is merely 2075, which is quite low, seems very sus.
{ This is an absolutely amazing video about weird chess algorithms :) And here is a very lovely article about someone's memories of his old competitive chess program: https://www.lkessler.com/brutefor.shtml. ~drummyfish }
Computers not only help people play chess, train their skills, analyze positions and perform research of games, but they also allow mathematical analysis of the game of chess itself and present a platform for things such as artificial intelligence. Knowledge gained from programming chess engines can then be applied in other areas as well. Since the dawn of the computer era computer chess has been a topic of passion and interest to computer scientists and programmers -- not just because nerds usually love both chess and computer and it's only natural they will desire to combine the two, and not only because making a machine beat human at the most famous and iconic of all intellectual games is just a great and symbolic achievement in itself, but also because computer chess is just so much fun. For example you may let various engines play against each other, just sit back and make your own mini computer engine tournament, compare the strength of your engines, let them play from funny starting positions, let a strong engine with material handicap play a weak engine, program a strong engine to play the worst moves possible or program it completely arbitrary or weird goals such as that it can only checkmate with a pawn or that it will just want to place all its pieces on white squares, and then watch it try hard to achieve the goal. It's endless joy.
Chess software is usually separated to libraries, chess engines and frontends. Library is just that -- a programming library that will help a programmer create some kind of chess program. Chess engine on the other hand is a complete program whose main purpose is to compute good chess moves, it is typically a CLI program capable of playing chess but also doing other things such as evaluating arbitrary positions, hinting best moves, saving and loading games etc. -- commonly the engine has some kind of custom CLI interface (flags, interactive commands it understands, ...) plus a support of some standardized text communication protocol, most notably XBoard (older one, more KISS) and/or UCI (newer, more bloated). It is also a must for an engine to support other standard formats such as FEN (Forsyth–Edwards notation, way of encoding a chess position as a text string), PGN (portable game notation, way of encoding games as text strings) etc. And then there are frontends (also called boards) -- these are, almost by definition, GUI programs that help mere mortal people interact with the underlying engine (and do other things like play against other humans, annotate games and so on). There also exist other kinds of programs, e.g. tournament managers that automatically run a tournament of several chess engines, calculate their strength etc. As seen, the chess "ecosystem" exemplifies a textbook modularity (it is possible to easily drop-in replace any part of your chess system as they are all just black boxes with the same interface) and the whole system stands on a solid, standardized, relatively simple plain text protocols, giving a shining example of Unix philosophy and good design in practice. In an ideal world all games would be implemented this way.
Computers have already surpassed the best humans in their playing strength (we can't exactly assign Elo rating to an engine alone, as hardware it runs on plays a vital role, but as a general statement it's nowadays easy for anyone to carry around a pocket chess computer rated high above 3000 FIDE, i.e. capable of easily shattering even the world champion). As of 2023 the strongest chess engine is undoubtedly the FOSS engine Stockfish, with other strong ones being e.g. Leela Chess Zero (also FOSS), AlphaZero (proprietary by Google) or Komodo Dragon (proprietary). GNU Chess is a fairly strong free software engine by GNU. There are world championships for chess engines such as the Top Chess Engine Championship or World Computer Chess Championship. CCRL is a list of chess engines along with their Elo ratings deduced from tournaments they run. Despite the immense strength of modern engines, there are still some specific artificial situations in which a human beats the computer (shown e.g. in this video); this probably won't last long though.
The first chess computer that beat the world champion (at the time Gary Kasparov) in a full match was famously Deep Blue in 1997 (in single games Deep Blue also won in 1996). Alan Turing himself has written a chess playing algorithm but at his time there were no computers to run it, so he executed it by hand -- nowadays the algorithm has been implemented on computers (there are bots playing this algorithm e.g. on lichess).
Playing strength is not the only possible measure of chess engine quality, of course -- for example there are people who try to make the smallest chess programs (see countercomplex and golfing). As of 2022 the leading programmer of smallest chess programs seems to be Oscar Toledo G. (https://nanochess.org/chess.html). Unfortunately his programs are proprietary, even though their source code is public. The programs include Toledo Atomchess (392 x86 instructions), Toledo Nanochess (world's smallest C chess program, 1257 non-blank C characters) and Toledo Javascript chess (world's smallest Javascript chess program). He won the IOCCC. Another small chess program is micro-Max by H. G. Muller (https://home.hccnet.nl/h.g.muller/max-src2.html, 1433 C characters, Toledo claims it is weaker than his program). Other engines try to be strong while imitating human play (making human moves, even mistakes), most notably Maia which trains several neural networks that play like different rated human players.
{ Nanochess is actually pretty strong, in my testing it easily beat smallchesslib Q_Q ~drummyfish }
Visualizing chess state space can be interesting. Here is one idea: draw the board with all squares black except the ones with men which can be moved -- color these white. Now recursively replace each square with a similar picture: the black ones will stay black, the white ones will be replaced by boards where only the square to which the man in question can be moved will be colored white. And so on until certain depth. Of course the image will be getting very large quickly and will also be quite black, so some kind of improvement may be employed: for example make the black square as small as possible. Additional fanciness can also be added, e.g. maybe don't redraw the squares but just keep brightening them or whatever. Any chess game played can then be visualized as zooming into this large image. This kind of visualization may also be applied to any other game which is played on a board by "clicking" squares, i.e. also tic tac toe, go etc.
NOTE: our smallchesslib/smolchess engine is very simple, educational and can hopefully serve you as a nice study tool to start with :)
There is also a great online wiki focused on programming chess engines: https://www.chessprogramming.org.
Programming chess is a fun and enriching experience and is therefore recommended as a good exercise. There is nothing more satisfying than writing a custom chess engine and then watching it play on its own.
The core of chess programming is writing the AI. Everything else, i.e. implementing the rules, communication protocols etc., is usually pretty straightforward (but still a good programming exercise). Nevertheless, as the chess programming wiki stresses, one has to pay a great attention to eliminating as many bugs as possible; really, the importance of writing automatic tests can't be stressed enough as debugging the AI will be hard enough and can become unmanageable with small bugs creeping in. However to make the AI good it's important to optimize the functions that work with the board, i.e. it's important to be able to generate moves quickly, quickly detect checks/mates and so on (because the AI will be checking billions of positions, any optimization will allow to search many more positions). Thought has to go into choosing right data structures so as to allow nice optimizations, for example board representation plays an important role -- main approaches here are for example having a 8x8 2D array holding each square's man, keeping a list of men (each explicitly recording its coordinates) or bitboards (8x8 times bit arrays, one for each piece type, recording where each man is placed).
The AI itself works traditionally on the following principle: firstly we implement so called static evaluation function -- a function that takes a chess position and outputs its evaluation number which says how good the position is for white vs black (positive number favoring white, negative black, zero meaning equal, units usually being in pawns, i.e. for example -3.5 means black has an advantage equivalent to having extra 3 and a half pawns; to avoid fractions we sometimes use centipawns, i.e. rather -350). This function considers a number of factors such as total material of both players, pawn structure, king safety, men mobility and so on. Traditionally this function has been hand-written (also called HCE, hand crafted evaluation), nowadays it is being replaced by a learned neural network (NNUE) which showed to give superior results (e.g. Stockfish still offers both options, however the neural net seems to save about half of the computation time); for starters you probably want to write a simple evaluation function manually. However even a manually crafted evaluation function may later on be fine tuned by some kind of machine learning -- the algorithm stays the same but the parameters, such as exact values of chessmen or bonus points for certain patterns on the board (connected rooks, good pawn structure etc.), may be determined e.g. by brute force trial and error or with smarter techniques like evolutionary programming, to maximize the playing strength of the engine.
Note: if you could make a perfect evaluation function that would completely accurately state given position's true evaluation (considering all possible combinations of moves until the end of game), you'd basically be done right there as your AI could just always make a move that would take it to the position which your evaluation function rated best, which would lead to perfect play by searching just to depth 1. Though neural networks got a lot closer to this ideal than we once were, as far as we can foresee ANY evaluation function will always be just an approximation, an estimation, heuristic, many times far from perfect evaluation, so we cannot stop at this. We have to program yet something more. However some more relaxed engines that don't aim to be among the best can already work in the lazy way and be pretty good opponents -- see for example the Maia engine.
So secondly we need to implement a so called search algorithm -- typically some modification of the minimax algorithm, e.g. with alpha-beta pruning -- that recursively searches the game tree and looks for a move that will lead to the best result in the future, i.e. to position for which the evaluation function gives the best value (minimax in short: the evaluation of current position is the maximum of evaluations of all our moves, out of which evaluation of each is the minimum of all opponent's moves, i.e. the best opponent's response, then again we search for maximum of our moves, i.e. our best response, etc. until given depth). This basic principle, especially the search part, can get very complex as there are many possible weaknesses and optimizations. For example (somewhat counterintuitively) it turns out to be a good idea to do iterative deepening, i.e. first searching to depth 1, then to depth 2, then to depth 3 etc., rather than searching to depth N right away. But again, this is all too complicated to expand on here. Just note now that doing the search kind of improves on the basic static evaluation function by making it dynamic and so increases its accuracy greatly (of course for the price of CPU time spent on searching).
Exhaustively searching the tree to great depths is not possible even with most powerful hardware due to astronomical numbers of possible move combinations, so the engine has to limit the depth quite greatly and use various hacks, approximations, heuristics, caches etc.. Normally it will search all moves to a small depth (e.g. 2 or 3 half moves or plys) and then extend the search for interesting moves such as exchanges or checks. Maybe the greatest danger of searching algorithms is so called horizon effect which has to be addressed somehow (e.g. by detecting quiet positions, so called quiescence). If not addressed, the horizon effect will make an engine misevaluate certain moves by stopping the evaluation at certain depth even if the played out situation would continue and lead to a vastly different result (imagine e.g. a queen taking a pawn which is guarded by another pawn; if the engine stops evaluating after the queen's pawn capture, it will think it's a won pawn, when in fact it's a lost queen). There are also many techniques for reducing the number of searched tree nodes and speeding up the search, for example pruning methods such as alpha-beta (a basic, extremely efficient method of skipping the search of subtrees that can no longer affect the current node score, which subsequently works best with correctly ordering moves to search), or transposition tables (remembering already evaluated position so that they don't have to be evaluated again when encountered by a different path in the tree). Furthermore we may try to combine many different things together, for example exhaustive search for some situations along with monte carlo in others; we may also try to employ more machine learning, e.g. make a special neural net just for suggesting which moves and to what depth should be searched etc.
Ideas for further optimizations can possibly be gathered from symmetries of the board, i.e. given position may be "practically the same as another position, just flipped", which can help us quickly deduce its evaluation if we already know the symmetric position's evaluation (this may come handy with transposition tables etc.). Consider e.g. the following:
2b3R1/1pk2p2/8/p5P1/3N4/P1P5/1PK5/6r1 w - - 4 42 is vertically symmetric with 6R1/1pk5/p1p5/3n4/P5p1/8/1PK2P2/2B3r1 b - - 4 42.
1R3b2/2p2kp1/8/1P5p/4N3/5P1P/5KP1/1r6 w - - 4 42.
1R6/5kp1/5p1p/4n3/1p5P/8/2P2KP1/1r3B2 b - - 4 42.Alternative approaches: most engines work as described above (search plus evaluation function) with some minor or bigger modifications. The simplest possible stupid AI can just make random moves, which will of course be an extremely weak opponent (though even weaker can be made, but these will actually require more complex code as to play worse than random moves requires some understanding and searching for the worst moves) -- one might perhaps try to just program a few simple rules to make it a bit less stupid and possibly a simple training opponent for complete beginners: the AI may for example pick a few "good looking" candidate moves that are "usually OK" (pushing a pawn, taking a higher value piece, castling, ...) and aren't a complete insanity, then pick one at random only from those (this randomness can further be improved and gradually controlled by scoring the moves somehow and adding a more or less random value from some range to each score, then picking the moves with highest score). One could also try to just program in a few generic rules such as: checkmate if you can, otherwise take an unprotected piece, otherwise protect your own unprotected piece etc. -- this could produce some beginner level bot. Another idea might be a "Chinese room" bot that doesn't really understand chess but has a huge database of games (which it may even be fetching from some Internet database) and then just looking up what moves good players make in positions that arise on the board, however a database of all positions will never exist, so in case the position is not found there has to be some fallback (e.g. play random move, or somehow find the "most similar position" and use that, ...). As another approach one may try to use some non neural network machine learning, for example genetic programming, to train the evaluation function, which will then be used in the tree search. Another idea that's being tried (e.g. in the Maia engine) is pure neural net AI (or another form of machine learning) which doesn't use any tree search -- not using search at all has long been thought to be impossible as analyzing a chess position completely statically without any "looking ahead" is extremely difficult, however new neural networks have shown to be extremely good at this kind of thing and pure NN AIs can now play on a master level (a human grandmaster playing ultra bullet is also just a no-calculation, pure pattern recognition play) -- a paper called Grandmaster-Level Chess Without Search managed to implement pure NN engine that on Lichess achieved rating of 2895, close to the strongest engines on the site. Next, Monte Carlo tree search (MCTS) is an alternative way of searching the game tree which may even work without any evaluation function: in it one makes many random playouts (complete games until the end making only random moves) for each checked move and based on the number of wins/losses/draws in those playouts statistically a value is assigned to the move -- the idea is that a move that most often leads to a win is likely the best. Another Monte Carlo approach may just make random playouts, stop at random depth and then use normal static evaluation function (horizon effect is a danger but hopefully its significance should get minimized in the averaging). However MCTS is pretty tricky to do well. MCTS is used e.g. in Komodo Dragon, the engine that's currently among the best. Another approach may lie in somehow using several methods and heuristics to vote on which move would be best.
Many other aspects come into the AI design such as opening books (databases of best opening moves), endgame tablebases (precomputed databases of winning moves in simple endgames), clock management, pondering (thinking on opponent's move), learning from played games etc. For details see the above linked chess programming wiki.
See also ratings of computer engines at https://www.computerchess.org.uk/ccrl/4040/.
Here are some notable chess engines/computers/entities, as of 2024:
The exact rules of chess and their scope may depend on situation, this is just a sum up of rules generally used nowadays. Nowadays the official rules are considered to be those defined by FIDE.
The start setup of a chessboard is following (lowercase letters are for black men, uppercase for white men, on a board with colored squares A1 is black):
_______________
/8 |r n b q k b n r|
r | 7 |p p p p p p p p|
a | 6 |. . . . . . . .|
n | 5 |. . . . . . . .|
k | 4 |. . . . . . . .|
s | 3 |. . . . . . . .|
| 2 |P P P P P P P P|
\1 |R N B Q K B N R|
"""""""""""""""
A B C D E F G H
\_____________/
files
Players take turns in making moves, white always starts. A move consists of moving one (or in special cases two) of own men from one square to another, possibly capturing (removing from the board) one opponent's man -- except for a special en passant move capturing always happens by moving one man to the square occupied by the opposite color man (which gets removed). Of course no man can move to a square occupied by another man of the same color. A move can NOT be skipped. A player wins by giving a checkmate to the opponent (making his king unable to escape attack) or if the opponent resigns. If a player is to move but has no valid moves, the game is a draw, so called stalemate. If neither player has enough men to give a checkmate, the game is a draw, so called dead position. There are additional situation in which game can be drawn (threefold repetition of position, 50 move rule). Players can also agree to a draw. A player may also be declared a loser if he cheated, if he lost on time in a game with clock etc.
The individual men and their movement rules are (no man can move beyond another, except for knight who jumps over other men):
| man | symbol | ~value | movement | comment |
|---|---|---|---|---|
| pawn | P | 1 | 1F, may also 2F from start, captures 1F1L or 1F1R, also en passant | promotes on last row |
| knight | N | 3 | L-shape (2U1L, 2U1R, 2R1U, 2R1D, 2D1R, 2D1L, 2L1U, 2L1D), jumps over | |
| bishop | B | 3.25 | any distance diagonally | stays on same color sq. |
| rook | R | 5 | any distance orthogonally (U, R, D or L) | can reach all sq. |
| queen | Q | 9 | like both bishop and rook | strongest piece |
| king | K | inf | any of 8 neighboring squares |
{ Cool players call knights horses or ponies and pawns peasants, rook may be called a tower and bishop a sniper as he often just sits on the main diagonal and shoot pieces that wonder through. Also pronounce en passant as "en peasant". Nakamura just calls all pieces a juicer. ~drummyfish }
Check: If the player's king is attacked, i.e. it is immediately possible for an enemy man to capture the king, the player is said to be in check. A player in check has to make such a move as to not be in check after that move.
A player cannot make a move that would leave him in check! This also implies that the two kings on the board can never stand right next to each other (this can be remembered by reminding oneself the kings aren't gay and don't want to touch each other).
Castling: If a player hasn't castled yet and his king hasn't been moved yet and his kingside (queenside) rook hasn't been moved yet and there are no men between the king and the kingside (queenside) and the king isn't and wouldn't be in check on his square or any square he will pass through or land on during castling, short (long) castling can be performed. In short (long) castling the king moves two squares towards the kingside (queenside) rook and the rook jumps over the king to the square immediately on the other side of the king.
Promotion: If a pawn reaches the 1st or 8th rank, it is promoted, i.e. it has to be switched for either queen, rook, bishop or knight of the same color.
Checkmate: If a player is in check but cannot make any move to get out of it, he is checkmated and lost.
En passant (aka "surprise motherfucker", pronounced as en peasant): If a pawn moves 2 squares forward (from the start position), in the immediate next move the opponent can take it with a pawn in the same way as if it only moved 1 square forward (the only case in which a man captures another man by landing on an empty square).
Threefold repetition is a rule allowing a player to claim a draw if the same position (men positions, player's turn, castling rights, en passant state) occurs three times (not necessarily consecutively). The 50 move rule allows a player to claim a draw if no pawn has moved and no man has been captured in last 50 moves (both players making their move counts as a single move here).
Chess stats are pretty interesting. Thanks a lot e.g. to OEIS and Lichess (and NOT thanks to fucking capitalist idiots like chess dot com) we have some great public domain databases and analyses of billions of games played between both people and computers, and thanks to chess engines we can generate new and new on demand, so naturally many people create cool statistics, look for patterns and oddities. This can be very insightful and entertaining.
{ Some chess world records are here: https://timkr.home.xs4all.nl/records/records.htm. ~drummyfish }
Number of possible games is not known exactly, Shannon estimated it at 10^120 (lower bound, known as Shannon number). Number of possible games by plies played is 20 after 1, 400 after 2, 8902 after 3, 197281 after 4, 4865609 after 5, and 2015099950053364471960 after 15 (OEIS A048987). { I plotted the ratio of subsequent terms of the sequence and they seem to form a quite predictable pattern, a kind of zig-zag line. I tried to quickly extrapolate this with the curve (5 * x)^0.65 + 17 and estimated the number of games after ply 30 to be 1310^44. ~drummyfish }
Similarly the number of possibly reachable positions (position for which so called proof game exists) is not known exactly, some upper estimates have been made, lower bounds are much harder to set. The estimates are placed around 10^40 or 10^50 at most. Here is a site that gives a proven upper estimate of 45193640626062205213735739171550309047984050718 (2^155), also providing a more precise one of 7728772977965919677164873487685453137329736522 (~10^45.888, ~2^152) which was however proven with a program that's a bit obscure and less trustworthy. Numbers of possible positions by plies are 20 after 1, 400 after 2, 5362 after 3, 72078 after 4, 822518 after 5, and 726155461002 after 11 (OEIS A083276).
Shortest possible checkmate is by black on ply number 4 (so called fool's mate); in fact there are 8 different games that can end like this. As of 2022 the longest known forced checkmate is in 549 moves -- it has been discovered when computing the Lomonosov Tablebases. EDIT: now it seems there is one in 584 moves. Please note this: there most likely exist much longer forced mates, these are just the KNOWN ones. Consider e.g. that if black blunders a queen in the opening, the game is very likely a theoretical win for white since then, i.e. a forced mate, and with perfect play black can probably resist for very long. However such situations are too complex to explore fully.
Average game of chess lasts 40 (full) moves (80 plies). Average branching factor (number of possible moves at a time) is around 33. Maximum number of possible moves in a position seems to be 218 (FEN: R6R/3Q4/1Q4Q1/4Q3/2Q4Q/Q4Q2/pp1Q4/kBNN1KB1 w - - 0 1). As for total number of legal moves, if we consider only squareFrom-squareTo notation (such as e3e5, without recording chessmen, promotions etc.), there are 1792 different moves that can ever legally be performed.
Win rates by color: white normally has a considerable statistical advantage. The following is a table showing some win rate statistics:
| database | white wins | black wins | draws |
|---|---|---|---|
| human OTB master chess (Masters) | 32% | 23% | 45% |
| human online chess (Lichess) | 50% | 46% | 4% |
| human online chess 960 (Lichess, welyab) | 49.1% | 47.1% | 3.8% |
| human online chess, quick games (chessmonitor bullet) | 50% | 47% | 3% |
| computer chess, long games (CCRL 40/15) | 29.5% | 20.2% | 50.3% |
| computer chess, long games (TCEC) | 33.1% | 11.1% | 55.8% |
| computer chess, quick games (CCRL Blitz) | 31.6% | 22.4% | 46% |
| computer chess 960, long games (CCRL 40/2 FRC) | 35.7% | 27.7% | 36.6% |
| computer chess 324 (CCRL chess324) | 22.3% | 7.2% | 70.5% |
| average (chess) | 37.7% | 28% | 34.3% |
| average (chess 960 and 324) | 35.7% | 27.3% | 37% |
What is the longest possible game? It depends on the exact rules and details we set, for example if a 50 move rule applies, a player MAY claim a draw but also doesn't have to -- but if neither player ever claims a draw, a game can be played infinitely -- so we have to address details such as this. Nevertheless the longest possible chess game under certain rules has been computed by Tom7 at 17697 half moves in a paper for SIGBOVIK 2020. Chess programming wiki states 11798 half moves as the maximum length of a chess game which considers a 50 move rule (1966 publication).
The longest game played in practice is considered to be the one between Nikolic and Arsovic from 1989, a draw with 269 moves lasting over 20 hours. For a shortest game there have been ones with zero moves; serious decisive shortest game has occurred multiple times like this: 1.d4 Nf6 2.Bg5 c6 3.e3 Qa5+ (white resigned).
Best players ever: a 2017 paper called Who is the Master? analyzed 20 of the top players of history based on how good their moves were compared to Stockfish, the strongest engine. The resulting top 10 was (from best): Carlsen (born 1990 Norway, peak Elo 2882), Kramnik (born 1975 Russia, peak Elo 2817), Fischer (born 1943 USA, peak Elo 2785), Kasparov (born 1963 Russia, peak Elo 2851), Anand (born 1969 India, peak Elo 2817), Khalifman, Smyslov, Petrosian, Karpov, Kasimdzhanov. It also confirmed that the quality of chess play at top level has been greatly increasing. The best woman player in history is considered to be Judit Polgar (born 1976 Hungary, peak Elo 2735), which still only managed to reach some 49th place in the world; by Elo she is followed by Hou Yifan (born 1994 China, peak Elo 2686) and Koneru Humpy (born 1987 India, peak Elo 2623). Strongest players of black race (NOT including brown, e.g. India): lol there don't seem to be many black players in chess :D The first black GM only appeared in 1999 (!!!!!)) -- Maurice Ashley (born 1966 Jamaica, peak rating 2504) who is also probably the most famous black chess player, though more because of his commentator skills; Pontus Carlsson (peak Elo 2531) may be strongest. { Sorry if I'm wrong about the strongest black player, this information is pretty hard to find as of course you won't find a race record in any chess player database. So thanks to political correctness we just can't easily find good black players. ~drummyfish } Strongest engine is currently the latest version of Stockfish NNUE.
How much Elo is one pawn worth in odds games? I.e. if we let a player start with a disadvantage of N pawns, how much will his Elo drop? Firstly this depends on the rating of both players -- giving a rook to a 200 Elo player does almost nothing while in a master-level game such disadvantage presents a fatal blow. According to this website one pawn advantage is approximately equal to 100, 200 and 300 Elo increase for average player ratings 1250, 2000 and 2500 respectively.
What is the most typical game? We can try to construct such a game from a game database by always picking the most common move in given position. Using the lichess database at the time of writing, we get the following incomplete game (the remainder of the game is split between four games, 2 won by white, 1 by black, 1 drawn):
1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 Nxe4 8. O-O Bxc3 9. d5 Bf6 10. Re1 Ne7 11. Rxe4 d6 12. Bg5 Bxg5 13. Nxg5 h6 14. Qe2 hxg5 15. Re1 Be6 16. dxe6 f6 17. Re3 c6 18. Rh3 Rxh3 19. gxh3 g6 20. Qf3 Qa5 21. Rd1 Qf5 22. Qb3 O-O-O 23. Qa3 Qc5 24. Qb3 d5 25. Bf1
Note on good and BAD play: as we'll be looking at WORST moves and games, there's a similar catch as when looking for the BEST ones (see note on perfect play above). When judging something as good or bad, we have to ask "good or bad considering WHAT kind of players?" (what skill, what goal, what kind of behavior, ...) -- best move for an engine may require precise play and so may not be best for human, and best move for a grandmaster may not be the best for average player, AND also a good move against human may be not best against a computer and vice versa. For example when looking for the worst move in a position, the first we think of is this: consider all moves and take the one which will take us to a position that has the worst evaluation by computer engine. This is quite cool, but not always and may not really be what we want, because when evaluating the position, the computer assumes GOOD play from both sides. So when we e.g. flip the rules and try to make computers play the worst moves and get themselves mated, they should rather assume the opponent to play the WORST moves, we want a different kind of estimate -- here it's not enough to offer opponent a checkmate, but also ensure he MUST give it. So these are some things to keep in mind.
What's the best and worst opening move according to the engines? With what's been said above, the answer will also depend on which engine (what evaluation function) you use and to what depth you search. The situation is basically this: both engines and humans are deciding between e4 or d4 for the best move, opinions differ and strongest engines currently oscillate between e4 and d4 as we keep analyzing the starting position deeper and deeper. According to Lichess cloud database (accessible via public API) that stores stockfish evaluations for various positions, e4 leads to the best evaluated position (18 centipawn, evaluated to depth 70), closely followed by d4 and Nf3 (both 17 centipawn, depth 47 and 56) and c4 (12 centipawn, depth 59). Lichess stockfish is currently an older version (14) also running in the web browser, so not absolutely strongest, but still very strong. On Chessbase (proprietary database) someone analyzed the starting position to depth 88 with stockfish 18 (currently the strongest engine) -- the evaluation is 0.10 with the best moves, both equally evaluated at 0.06, being unsurprisingly e4 and d4. So pick one. Worst move, as in "leading to worst evaluation in Lichess database" (also usually given by humans), is by far g4 with evaluation -96 centipawn (depth 52) -- almost a whole pawn, i.e. stockfish says that by playing this move you basically just throw away your pawn immediately. Another bad move is apparently f3 (-76, depth 40), Nh3 (-42), Na3 (-33), b4 or h4 (both -28). So g4 is likely the worst move under normal conditions, however if we play an opponent who is also trying to play the worst moves, i.e. we flip the rules and make each player try to get himself mated (in a computer engine flip the sign of the evaluation function), the engine actually elects e3 as the worst move, because that allows the white queen to immediately run out, attack the enemy king face to face and force him to take it.
How big is the white's starting move advantage? Based on the above evaluations of all starting moves the initial position is rated at about 10 centipawn, i.e. with this specific engine and search depth we are told white has, in material terms, an advantage of about a tenth of a pawn.
What's the perfect game according to an engine? Again, this will vary depending on new and better versions of engines coming out, on hardware, time we spend on computing moves etc. The following annotated draw was produced by taking a few first highly analyzed moves from the Lichess cloud database and letting the rest of the game be played by stockfish 17, the strongest available engine at the time, at a reasonably powerful desktop PC, giving each player 90 minutes plus 10 second increment, with endgame tablebases proving that since 7 men on the board the game is really a theoretical draw:
1. e4 {Lichess } e5 {Lichess } 2. Nf3 {Lichess } Nc6 {Lichess }
3. Bb5 {Lichess } Nf6 {Lichess } 4. O-O {+0.10/49} Nxe4 {-0.06/49}
5. Re1 {+0.12/46} Nd6 {-0.06/45} 6. Nxe5 {+0.09/49} Be7 {-0.07/46}
7. Bf1 {+0.09/47} Nxe5 {-0.06/42} 8. Rxe5 {+0.15/44} O-O {-0.10/43}
9. Nc3 {+0.20/58} Bf6 {-0.09/43} 10. Re1 {+0.13/43} Re8 {-0.04/41}
11. Nd5 {+0.08/46} Rxe1 {-0.10/42} 12. Qxe1 {+0.12/49} b6 {-0.12/45}
13. Nxf6+ {+0.13/44} Qxf6 {-0.16/45} 14. c3 {+0.16/56} Bb7 {-0.14/40}
15. d3 {+0.12/42} Re8 {-0.13/42} 16. Qd1 {+0.12/43} c5 {-0.11/40}
17. Qg4 {+0.18/41} Bc6 {-0.12/42} 18. Bd2 {+0.10/43} g6 {-0.10/39}
19. Rc1 {+0.12/42} h5 {-0.10/46} 20. Qg3 {+0.13/39} b5 {-0.12/47}
21. b3 {+0.02/48} a5 {-0.02/40} 22. Bg5 {+0.03/47} Qe6 {-0.02/45}
23. Bd2 {+0.00/45} Qf6 {-0.01/44} 24. a3 {+0.08/48} Kh7 {+0.00/42}
25. Qf4 {+0.03/46} Qxf4 {+0.00/48} 26. Bxf4 {+0.00/38} Nf5 {+0.00/52}
27. f3 {+0.00/43} f6 {+0.00/54} 28. Kf2 {+0.00/47} Ra8 {+0.00/48}
29. Bc7 {+0.00/52} b4 {+0.00/63} 30. a4 {+0.00/56} Bd5 {+0.00/53}
31. d4 {+0.00/49} Bxb3 {+0.00/59} 32. dxc5 {+0.00/60} Bxa4 {+0.00/60}
33. Ra1 {+0.00/76} Bc6 {+0.00/63} 34. cxb4 {+0.00/53} axb4 {+0.00/47}
35. Rxa8 {+0.00/48} Bxa8 {+0.00/55} 36. Ba5 {+0.00/51} Nd4 {+0.00/56}
37. Bxb4 {+0.00/47} Kg7 {+0.00/50} 38. Bd2 {+0.00/54} h4 {+0.00/69}
39. Bf4 {+0.00/64} Bc6 {+0.00/61} 40. Bd3 {+0.00/50} Ne6 {+0.00/78}
41. Bd6 {+0.00/54} Nd4 {+0.00/63} 42. Bf4 {+0.00/69} Ne6 {+0.00/65}
43. Bd6 {+0.00/57} Ng5 {+0.00/56} 44. Bf4 {+0.00/68} Nf7 {+0.00/56}
45. Ke3 {+0.00/70} Nd8 {+0.00/56} 46. Bc7 {+0.00/58} Ne6 {+0.00/62}
47. Bd6 {+0.00/69} Nd8 {+0.00/62} 48. Kf4 {+0.00/63} Nf7 {+0.00/80}
49. Kg4 {+0.00/58} g5 {+0.00/60} 50. Kh3 {+0.00/46} Nd8 {+0.00/58}
51. Kg4 {+0.00/54} Ne6 {+0.00/66} 52. f4 {+0.00/50} Bxg2 {+0.00/66}
53. fxg5 {+0.00/47} fxg5 {+0.00/65} 54. Bf5 {+0.00/70} Kf6 {+0.00/85}
55. Bxe6 {+0.00/87} dxe6 {+0.00/78} 56. Bc7 {+0.00/80} h3 {+0.00/90}
57. Ba5 {+0.00/59} Ke5 {+0.00/73} 58. Kxg5 {+0.00/67} Kd5 {+0.00/85}
59. Bb6 {+0.00/65} e5 {+0.00/74} 60. Ba7 {+0.00/84} Bf1 {+0.00/69}
61. Kg4 {+0.00/72} e4 {+0.00/89} 62. Kf4 {+0.00/95} Bb5 {+0.00/89}
63. Bb6 {+0.00/65} Bc6 {+0.00/84} 64. Kg3 {+0.00/69} e3 {+0.00/66}
65. Kxh3 {+0/80,draw} e2 {+0.00/84} 66. Ba5 {+0.00/70} Kxc5 {+0.00/93}
67. Kg3 {+0.00/78} Kd4 {+0.00/85} 68. Kf2 {+0.00/89} Kd3 {+0.00/82}
69. Bb4 {+0.00/88} Be4 {+0.00/88} 70. Ba5 {+0.00/85} Bh7 {+0.00/91}
71. h4 {+0.00/77} Bg6 {+0.00/72} 72. Bb4 {+0.00/72} Bh5 {+0.00/81}
73. Be1 {+0.00/65} Bg6 {+0.00/85} 74. Kf3 {+0.00/83} Bh5+ {+0.00/69}
75. Kf2 {+0.00/87} Kc2 {+0.00/70} 76. Ke3 {+0.00/77} Kd1 {+0.00/76}
77. Kf2 {+0.00/69} Bf3 {+0.00/70} 78. Bb4 {+0.00/81} Bh5 {+0.00/77}
79. Ke3 {+0.00/65} e1=R+ {+0.00/76} 80. Bxe1 {+0.00/58} Kxe1 {+0.00/72}
81. Kf4 {+0.00/80} Kf2 {+0.00/87} 82. Kg5 {+0.00/84} Bf7 {+0.00/83}
83. h5 {+0.00/98} Bxh5 {+0.00/82} 1/2-1/2 {insufficient material}
What's the theoretically worst game possible, and how to find out? This is easy: just sit two women at a chessboard and watch :D OK, jokes aside -- like with the perfect game we will probably never know, plus there are the pecularities mentioned above about how we really define "bad play". Anyway we may try this: take the best engine and just revert its evaluation function, i.e. literally flip the sign of evaluation (in practice we usually have to handle some additional stuff in the code that relied on normal evaluation) -- this should basically internally revert the rules of chess to trying to get mated, AND also make sure we assume the opponent is trying to do the same etc. This game will represent the serious effort to really force your opponent to beat you. Doing this with the current best engine, stockfish 17, giving both players 30 minutes plus 10 second increment, leaves us with the following beautifully terrible, excruciatingly long abomination of a game:
1. e3 e6 2. Qh5 Qg5 3. Qxf7+ Kd8 4. Qe7+ Kxe7 5. f4 Qg3+ 6. Ke2 Qf3+ 7. Kd3 Qd5+ 8. Ke2 Qd3+ 9. Kf3 Qe2+ 10. Bxe2 Kf6 11. Bd3 Nc6 12. Kg4 h5+ 13. Kh3 Rh7 14. Bf5 Ba3 15. Nc3 Ke7 16. Bg4 Nd4 17. Ne4 hxg4+ 18. Kg3 Rh3+ 19. gxh3 Nf3 20. Nd6 c6 21. Ne2 Nf6 22. Nxb7 Ne4+ 23. Kg2 Nh4+ 24. Kg1 Ng2 25. Nc3 Ke8 26. Nd5 Ng3 27. Kf2 Ne1 28. Nd8 Bb7 29. h4 a6 30. Ne7 Nf1 31. Kg1 d5 32. Nxe6 Nf3+ 33. Kf2 Ne1 34. Ke2 Nd3 35. Kd1 Nxb2+ 36. Ke2 Ng3+ 37. Kf2 Nf1 38. Nc7+ Kf7 39. Ne8 Bc5 40. Nc8 Bxe3+ 41. Kg2 Bb6 42. Na7 Bd8 43. Nf6 Rb8 44. a3 Ke7 45. d4 Rc8 46. Be3 Bc7 47. Nb5 Be5 48. Rd1 Nd3 49. Rc1 Nb4 50. a4 Rg8 51. Nd7 Ke6 52. Nb6 Nd2 53. Bg1 Nf1 54. Kf2 Nd3+ 55. Ke2 Rc8 56. Nc4 Rb8 57. Nca3 Rd8 58. f5+ Ke7 59. h3 Ne3 60. f6+ Ke6 61. Nc7+ Kf5 62. Rf1+ Kg6 63. Na8 Nc1+ 64. Kd2 Bc7 65. Nb5 Ba5+ 66. c3 Nc2 67. Rf3 Rc8 68. h5+ Kh7 69. Re3 Rc7 70. h4 g6 71. Re4 Rg7 72. Kd1 Bxc3 73. f7 Ne3+ 74. Kxc1 Bb2+ 75. Kd2 Nc4+ 76. Ke2 Ne5 77. f8=N+ Kg8 78. Nd6 Rh7 79. Rh3 Bc1 80. Rf3 Bf4 81. Nf7 Rh6 82. Kf2 Nd7 83. Rh3 Rh7 84. Ke2 Nb8 85. Nh8 a5 86. Rh2 Ba6+ 87. Kf2 Be3+ 88. Ke1 Bd2+ 89. Kd1 Re7 90. Kc2 Kg7 91. Rh1 Re5 92. Nh7 Bb7 93. Nf7 Be1 94. Kd3 g5 95. Nh8 Ba6+ 96. Ke3 Bd2+ 97. Kf2 Be1+ 98. Ke3 Be2 99. h6+ Kg8 100. Nb6 Bd2+ 101. Kf2 g3+ 102. Kg2 Bf1+ 103. Kf3 Be2+ 104. Kg2 Bf1+ 105. Kf3 dxe4+ 106. Kxg3 Be1+ 107. Bf2 Bh3 108. Nc8 Re7 109. Nf6+ Kf8 110. Ng6+ Kf7 111. Nd6+ Kxf6 112. Ne8+ Kf7 113. Ne5+ Kf8 114. Nd7+ Kg8 115. Nc7 Re5 116. Nd5 Bg2 117. Nb4 Bf1 118. Rh3 Bb5 119. Kg4 Ba6 120. Rf3 Rf5 121. Nc5 Kf8 122. d5 Ke7 123. Nd7 Rf4+ 124. Kh3 Rf6 125. Nc5 Bf1+ 126. Kg3 Rd6 127. Nxc6+ Ke8 128. Rf8+ Kxf8 129. Ne6+ Kf7 130. Nb4 Bh3 131. Nxg5+ Ke7 132. Ne6 Rb6 133. Kf4 Bf5 134. Bc5+ Rd6 135. Bg1 Bd2+ 136. Ke5 Rxd5+ 137. Nxd5+ Kd7 138. Nb6+ Ke8 139. Bc5 Bf4+ 140. Kd4 Bd6 141. Bb4 Bg4 142. Kc3 Be2 143. Nc5 Na6 144. Nd3 Nc5 145. Nc8 Bd1 146. Kc4 Bb3+ 147. Kc3 Ne6 148. Kd2 Bd1 149. Ne5 Ng7 150. Nd3 Bc5 151. Nf2 Kd7 152. Kc3 Bd4+ 153. Kd2 Ke6 154. Ng4 Bc3+ 155. Ke3 Nf5+ 156. Kf4 Bd2+ 157. Ne3 Bxe3+ 158. Kxe4 Be2 159. Bd6 Nd4 160. Ne7 Bd3+ 161. Kxe3 Ne2 162. Bb4 Be4 163. h5 Nf4 164. Nf5 Kd5 165. Ne7+ Ke6 166. Nf5 Ke5 167. Bc3+ Kd5 168. Bb4 Bf3 169. Kf2 Ke5 170. Kg3 Ne2+ 171. Kh4 Ng3 172. Ne3 Bg4 173. Bd6+ Ke4 174. Kg5 Kf3 175. Bb4 Ne4+ 176. Kg6 Bd7 177. Kf7 Nc3 178. Kf6 Kf4 179. Bd6+ Ke4 180. Bb4 Nd5+ 181. Kg5 Bb5 182. Nc4 Ne3 183. Nd2+ Kd5 184. Nc4 Kd4 185. Kf4 Nd5+ 186. Kg5 Be8 187. Bc3+ Kd3 188. Bb4 Bd7 189. Nd6 Bb5 190. Nc4 Be8 191. Kf5 Ne3+ 192. Ke5 Ke2 193. Kf4 Ng2+ 194. Ke4 Bc6+ 195. Ke5 Ne3 196. Kf4 Kd3 197. Ke5 Nd5 198. Nb2+ Ke2 199. Nd3 Nf4 200. Ne1 Nd3+ 201. Kd4 Nc5 202. Nd3 Nb3+ 203. Ke5 Nd4 204. Nf4+ Kf3 205. Nd3 Be8 206. Ne1+ Ke3 207. Bd2+ Ke2 208. Kf4 Bxa4 209. Nd3 Kd1 210. Bb4 Ne2+ 211. Kf5 Bd7+ 212. Ke5 Nc1 213. Ke4 Kc2 214. Nb2 Bc6+ 215. Ke3 Ne2 216. h7 Nc3 217. h8=N Nd1+ 218. Kf4 Ne3 219. Nf7 Nf1 220. Ng5 Bf3 221. Ne6 Kc1 222. Nc5 Bb7 223. Nb3+ Kb1 224. Nc1 Kc2 225. Nb3 Ba8 226. Kg4 Bb7 227. Bd2 Ng3 228. Bb4 Bf3+ 229. Kh3 Bh1 230. Nc1 Bg2+ 231. Kh4 Bh3 232. Kg5 Ne2 233. Nb3 Bd7 234. Bc3 Nf4 235. Kh4 Ne2 236. Nd2 Ng3 237. Kg5 Ne2 238. Kh4 Be6 239. Nb3 Bg4 240. Na1+ Kb1 241. Nd3 Ng3 242. Kg5 Ne2 243. Bb2 Nf4 244. Kh4 Ne2 245. Nb4 Kxb2 246. Na2 Nf4 247. Kg3 Nh3 248. h6 Ka3 249. h7 Ka4 250. h8=N Kb5 251. Nb4 Ng5 252. Nf7 Ne4+ 253. Kh4 Kc4 254. Nb3 Kc3 255. Nd6 Ng5 256. Nc4 Bh3 257. Kh5 Bf5 258. Kh6 Bg6 259. Kg7 Nh7 260. Nd4 Nf6 261. Nb5+ Kb3 262. Nb2 Ng8 263. Nc2 Bf7 264. Kh7 Bg6+ 265. Kh8 Bh5 266. Nca3 Bf7 267. Na4 Kxa4 268. Nc3+ Kb4 269. Na4 Bd5 270. Kh7 Bf7 271. Kh8 Nf6 272. Kg7 Ng8 273. Kxf7 Kb3 274. Ke6 Ne7 275. Ke5 Nc6+ 276. Kd5 Nb4+ 277. Kc5 Nc2 278. Nb5 Ka2 279. Nb2 Ne3 280. Nd4 Nc4 281. Nd3 Nd2 282. Nb3 Kb1 283. Na1 Ne4+ 284. Kd4 Nd6 285. Nc2 Ka2 286. Na1 Kb1 287. Nc2 Ka2 288. Nc5 Kb2 289. Kd3 Nc4 290. Na4+ Kc1 291. Nb2 Nxb2+ 292. Kc3 Na4+ 293. Kd3 Nc5+ 294. Kc3 Na4+ 295. Kd3 Nc5+ 296. Kc3 Ne4+ 297. Kd3 Nf2+ 298. Kc3 Ne4+ 299. Kd3 Nf2+ 300. Kc3 Nd1+ 301. Kd3 Kb2 302. Ne1 a4 303. Kd2 Nf2 304. Ke2 Nh1 305. Nd3+ Kb1 306. Kf3 a3 307. Nb4 a2 308. Nxa2 Kxa2 1/2-1/2
Lichess analysis seems to only handle the first 150 moves, the evaluation graph explodes up and down and almost jumps through the roof. The following are the analysis results (for the first 150 moves). White: 15 inaccuracies, 15 mistakes, 97 blunders, 581 average centipawn loss, accuracy: 21%. Black: 11 inaccuracies, 17 mistakes, 97 blunders, 587 average centipawn loss, accuracy: 21%. That doesn't seem that bad, why aren't all moves blunders? Well, firstly the analysis is relatively quick (takes like 10 seconds for whole game), it likely doesn't see as deep as the engines who were given hours to play, but secondly we changed the rules of the game: the analyzing engine still assumes the players will be playing good moves, which is not the case.
For comparison here is another bad game in which we just take regular stockfish 17 and make moves like this: from all possible moves, minus the ones that draw, choose the one that leads to the position with worst evaluation for us. 3 seconds are given for evaluating each possible move, so we get something around a minute to make a move. For "mate in N" we take the move that gets us mated sooner as better, and to decide between several "mate in N" moves with same N we try to estimate the worst by taking an average static evaluation of the board to depth 3 (for technical reasons we use smallchesslib's evaluation) -- this should help us prefer positions in which there are more ways to get ourselves mated or in which we at least lost most material and other advantage on average. This game embodies the effort to make the worst blunder in each move in a regular game of chess -- as such we won't see too many "forced blunders", just great many generous offers that keep being turned down. In result this produced another terribly long game:
{ My computer basically spent the whole day computing this game instead of mining Monero, so please enjoy :D NOTE: I don't actually mine Monero of course, I'm not stupid enough for that. ~drummyfish }
1. g4 f5 2. f3 g5 3. Kf2 Kf7 4. Ke3 Ke6 5. Kd4 Qe8 6. b4 Qh5 7. f4 Kf6 8. Ke3 Qh3+ 9. Kd4 Qc3+ 10. Kd5 Qb2 11. h4 h5 12. Nf3 Bh6 13. Kc5 a6 14. d4 Qxd4+ 15. Nxd4 Ra7 16. c4 Kg7 17. Bg2 Kf6 18. gxh5 c6 19. Qa4 Rh7 20. Qa5 Ra8 21. Qb6 Ra7 22. Qa5 Ra8 23. Qb6 Rf7 24. Bb2 d5 25. Nd2 Ra7 26. Rh3 a5 27. Qa6 e6 28. b5 g4 29. Rf3 Bd7 30. b6 Bg7 31. Kd6 Rf8 32. Kc7 Rf7 33. Kd6 Rf8 34. Kc7 Rd8 35. c5 g3 36. Kd6 Rf8 37. Kc7 Rf7 38. Kd6 Rf8 39. Kc7 Rf7 40. Kd8 Nxa6 41. Rc3 Ne7 42. Ne4+ fxe4 43. a4 Nb8 44. Nxe6 Kf5 45. Bf3 Rf6 46. Rd1 e3 47. Nf8 Kxf4 48. Be4 Rd6 49. Nxd7 Bf6 50. Rdd3 Kxe4 51. Rc2 Bd4 52. Rb3 Rf6 53. Nf8 Rf3 54. Rd2 Rf5 55. Ba1 Ng6 56. Rb5 g2 57. Bc3 Ne5 58. Bb2 Nbd7 59. Kc8 Nf6 60. Kd8 Ne8 61. h6 Nf6 62. Bc1 g1=B 63. Ke7 Rg5 64. Rbb2 Kf4 65. Nh7 Ne8 66. h5 Rg4 67. Kxe8 Nf7 68. Rdc2 Bf6 69. Kf8 Ke4 70. Rc3 Rg7 71. Ng5+ Kd4 72. Ke8 Bd8 73. Ne4 Bh2 74. h7 Rg8+ 75. Kd7 Bd6 76. h6 B8e7 77. Ng3 Ke5 78. Rc4 Bc7 79. Rd4 Kf6 80. h8=N Kg5 81. Rc4 Nd6 82. Rd2 Raa8 83. Nh1 Ra7 84. Ke6 Rg7 85. Ke5 Bcd8 86. bxa7 b6 87. Ng6 Nc8 88. Nf8 Nd6 89. a8=N b5 90. Ng6 Bb6 91. Bb2 Nc8 92. Nf8 Na7 93. Nc7 Bbxc5 94. h7 Bd4+ 95. Ke6 Ba3 96. Ng3 Bc3 97. Rxc6 b4 98. h8=N Nb5 99. Rd6 Kh6 100. Kf5+ Bf6 101. Nh7 d4 102. Na8 Rxh7 103. Nh5 b3 104. Ba1 Na7 105. Kf4 Rf7 106. Ng6 Re7 107. Nf8 Rb7 108. Ng7 d3 109. Kg3 Rb4 110. Ng6 Bg5 111. Rf6 Bf4+ 112. Kh4 Rxa4 113. Rd6 dxe2 114. Be5 Nc8 115. Nb6 Ne7 116. Nh5 Bb2 117. Bd4 e1=R 118. Na8 Nc6 119. Bb6 Na7 120. Rc6 Nc8 121. Rc4 Ra3 122. Kg4 Kh7 123. Bd8 Rb1 124. Nh8 Bf6 125. Ng7 Kxg7 126. Rc5 Bh6 127. Rc4 Kf8 128. Nf7 Kg8 129. Rb4 Rd1 130. Nh8 Kg7 131. Kh5 Bf4 132. Be7 a4 133. Rf2 Bb8 134. Bd8 Rf1 135. Bb6 Bd4 136. Rf5 Rg1 137. Rf6 Na7 138. Rb5 Rc1 139. Kg5 Nc8 140. Ra5 Rc7 141. Rc5 Ba7 142. Rc4 Bc5 143. Rf8 Bd4 144. Rf6 Bc5 145. Rf8 Rf7 146. Rxa4 Bd4 147. Kh4 Bb8 148. Rd8 Ra1 149. Kh3 Rc7 150. Kh2 Rg1 151. Rg8+ Kf6 152. Rg2 Na7 153. Kh3 e2 154. Ba5 Bf2 155. Be1 Bh4 156. Ra5 Rf1 157. Rg7 Re7 158. Ra3 Rf7 159. Bf2 Ra1 160. Nb6 Ke7 161. Kg2 Re1 162. Nd7 Bf6 163. Ra1 Bh2 164. Bd4 Bb8 165. Ra2 Ra1 166. Rd2 Ra2 167. Nxf6 Ra1 168. Bb6 e1=R 169. Bd4 Re2+ 170. Bf2 Re3 171. Ne4 Ra6 172. Kg1 Re6 173. Nd6 Kf8 174. Rd1 R6e4 175. Rc1 Rc4 176. Be1 Rec3 177. Nf5 Rf4 178. Ne7 Rb4 179. Nf5 Rcc4 180. Nd6 Rb6 181. Rh7 Nc6 182. Ra1 Rc3 183. Bg3 Rc4 184. Be5 Ne7 185. Bf6 Ba7 186. Ra2 Rc2 187. Rh2 Ng6 188. Rd2 Re7 189. Kf2 Rc1 190. Rac2 Rg1 191. Bd4 b2 192. Nhf7 Rd7 193. Bxb2 Bb8 194. Ba1 Ra6 195. Nc8 Kg8 196. Rc6 Rd8 197. Rd3 Nh8 198. Bxh8 Rc1 199. Rc2 Ra8 200. Rd5 Rg1 201. Rd1 Bc7 202. Rc3 Ra6 203. Nb6 Rd7 204. Rc4 Bf4 205. Rc7 Bh6 206. Rc5 Rc7 207. Na8 Rb6 208. Rc2 Bf8 209. Rd4 Rg4 210. Rd6 Bh6 211. Ng5 Rc8 212. Ke3 Rd8 213. Rc1 Rc6 214. Rcd1 Rh4 215. Bd4 Bg7 216. Rh6 Bf8 217. Ne6 Rc4 218. Bf6 Rc5 219. Be5 Be7 220. Rc1 Rf8 221. Nb6 Bd8 222. Rb1 Rc6 223. Ng5 Rc7 224. Bd6 Rc2 225. Bc5 Rb2 226. Bd6 Rc2 227. Nd7 Rf5 228. Rb5 Rg2 229. Rb7 Rc2 230. Nc5 Rf7 231. Bc7 Bf6 232. Bh2 Rc1 233. Rc7 Be5 234. Rb6 Rcc4 235. Rb5 Rh8 236. Nh3 Rf2 237. Rcb7 Bb8 238. Rf7 Rd4 239. Rb2 Rf3+ 240. Ke2 Rd7 241. Ng1 Rb7 242. Kd2 Re3 243. Kc2 Rd3 244. Kb1 Rc3 245. Rb6 Rch3 246. Rb5 Rd7 247. Rb3 Rxh2 248. Ka1 R2h4 249. Na4 R4h5 250. Rd3 Re7 251. Re3 Bg3 252. Rf4 Re4 253. Ref3 Rf5 254. Rf1 Re2 255. R4f2 Kf8 256. Nf3 Rd5 257. Nd2+ Bf4 258. Kb2 Rd3 259. Rh2 Re4 260. Re2 Re8 261. Ka2 Rde3 262. Rb1 R3e4 263. Rbe1 Rc4 264. Ka3 Rh6 265. Nf1 Rb4 266. Rb1 Bb8 267. Rb3 Kg8 268. Re1 Kh8 269. Nb6 Rh2 270. Ng3 Rc4 271. Ne2 Rh3 272. Rf1 Ba7 273. Nc8 Bg1 274. Rf5 Rf4 275. Rg3 Re5 276. Nb6 Rd4 277. Rh5+ Rhxh5 278. Nc1 Rh3 279. Rb3 Re2 280. Na4 Rb4 281. Rd3 Bd4 282. Rf3 Kh7 283. Rg3 Kh8 284. Nc3 Bg1 285. Rg4 Rg3 286. Rf4 Rb5 287. Nd3 Rg4 288. Rb4 Rh4 289. Nf4 Rb8 290. Nd3 Re5 291. Nxe5 Re4 292. Na4 Rc4 293. Nc3 Re4 294. Na4 Rc4 295. Nc5 Bh2 296. Ra4 Ra8 297. Ncd7 Rb4 298. Ka2 Rb3 299. Nb8 Bg1 300. Ng4 Bb6 301. Ka1 Bd8 302. Ka2 Bb6 303. Ka1 Bd8 304. Ra2 Rd3 305. Ra6 Kg8 306. Nf6+ Kh8 307. Ng4 Rh3 308. Nh6 Rc3 309. Ng8 Rh3 310. Nh6 Ra7 311. Ra2 Re3 312. Kb2 Rc3 313. Ra5 Rf7 314. Nf5 Bg5 315. Ng7 Rd7 316. Nc6 Rd5 317. Ra3 Rb5+ 318. Rb3 Rb8 319. Rb6 Be7 320. Ne8 Kg8 321. Rb5 Bf6 322. Ka2 Re3 323. Nd8 Rb7 324. Ne6 Kh7 325. Rb4 Rd7 326. Ng5+ Kh8 327. Re4 Rf7 328. Kb1 Re2 329. Rb4 Ra2 330. Rf4 Bb2 331. Kc2 Rh7 332. Rf6 Ra6 333. Rc6 Rf7 334. Nf6 Rg7 335. Kd2 Ba3 336. Nfh7 Kg8 337. Nf8 Rf7 338. Ke2 Kh8 339. Ne4 Kg7 340. Nd6 Kxf8 341. Rc2 Rf5 342. Nf7 Rh6 343. Nh8 Rg6 344. Rd2 Rf4 345. Rd7 Rd4 346. Re7 Rd7 347. Kf2 Rc7 348. Re2 Rc2 349. Kf1 Bb2 350. Rd2 Bc1 351. Re2 Bb2 352. Ke1 Bc1 353. Nf7 Kg8 354. Nd8 Rf6 355. Re6 Rc4 356. Kd1 Rg6 357. Re5 Rc2 358. Re6 Bb2 359. Re2 Kh8 360. Re5 Rg5 361. Re6 Rg1+ 362. Re1 Kg8 363. Nf7 Re2 364. Rf1 Bf6 365. Ne5 Bh4 366. Ng4 Be1 367. Rf2 Rg3 368. Rf4 Rxg4 369. Kxe2 Kg7 370. Ke3 Bh4 371. Rd4 Bg3 372. Rc4 Kg6 373. Rd4 Kg7 374. Rd6 Rd4 375. Rh6 Kf8 376. Rd6 Rd1 377. Rd2 Kf7 378. Rd4 Ke6 379. Rd2 Bd6 380. Rxd6+ Ke5 381. Re6+ Kf5 382. Re7 Rf1 383. Re6 Kg5 384. Rh6 Rh1 385. Kd3 Kf4 386. Kd4 Rh3 387. Kc5 Kf3 388. Kd6 Rh5 389. Kc6 Rb5 390. Kd6 Rb3 391. Rg6 Ke3 392. Rh6 Ra3 393. Rg6 Rb3 394. Rh6 Ra3 395. Ke6 Ke4 396. Rh3 Kd4 397. Rh6 Rh3 398. Kf6 Kd5 399. Kf5 Kc4 400. Kf6 Kd4 401. Rh7 Kd3 402. Rh4 Kc3 403. Rc4+ Kb3 404. Ra4 Kc3 405. Ra6 Rg3 406. Ke6 Rf3 407. Kd6 Rg3 408. Ke6 Rf3 409. Kd6 Rh3 410. Ke7 Kd3 411. Ra7 Kc3 412. Ke8 Rf3 413. Kd7 Rg3 414. Ke7 Kd3 415. Rb7 Rh3 416. Ra7 Rg3 417. Rb7 Rg8 418. Rb8 Ke3 419. Rb7 Rd8 420. Rb8 Re8+ 421. Kd7 Re7+ 422. Kd8 Re8+ 423. Kd7 Re7+ 424. Kd8 Rb7 425. Ke8 Rb3 426. Kf7 Kf4 427. Rb7 Kf5 428. Ke7 Ke4 429. Kd7 Rxb7+ 430. Kd6 Re7 431. Kc5 Re5+ 432. Kd6 Re7 433. Kc5 Rd7 434. Kc4 Rd5 435. Kc3 Rd2 436. Kb4 Kd5 437. Kc3 Ke6 438. Kc4 Rd4+ 439. Kb3 Rc4 440. Ka2 Kd6 441. Kb2 Rc3 442. Ka1 Kc5 443. Ka2 Rb3 444. Ka1 Rb2 1/2-1/2
Again, Lichess only analyzed the first 150 moves and here it marked practically every move as a blunder (the rest are probably blunders so genius that the quick analysis didn't even reveal the genius behind that stupidity), because of our different definition of a bad move. Here are the statistics. White: 1 inaccuracy, 1 mistake, 147 blunders, 1610 average centipawn loss, accuracy: 2%. Black: 1 inaccuracy, 0 mistakes, 148 blunders, 1613 average centipawn loss, accuracy: 2%.
What is the rarest move? Some YouTube video tried to investigate this with the help of Lichess database. Things that immediately come to mind like en passant checkmates and checkmates by promoting to a knight are rare but not insanely rare. A crazily rare kind of move, which only appeared ONCE in the whole database, was a doubly disambiguatated (i.e. with the necessary specification of both rank and file of the bishop) checkmate by a bishop (specifically Bf1g2#, occurring in a 2022 game) -- this is rare because to need a double disambiguation for a bishop move it is necessary to underpromote two pawns to a bishop and then place them correctly. Yet rarer moves, which NEVER appeared in the database, were a doubly disambiguated knight checkmate with capture and doubly disambiguated bishop checkmate with capture, latter of which was judged less likely and therefore probably the rarest move ever.
The maximum number of black and white queen pairs placed on an empty board so that none is attacked is 12 (that is 12 white queens and 12 black ones). This number as a function of board size is the OEIS sequence A250000 and starts like this: 0, 0, 1, 2, 4, 5, 7, 9, 12, 14, 17, 21, 24, 28, 32, ... Insofar as chess curiosities go, OEIS is a fairly cool place to check out too, they examine interesting things such as knight walks on infinite chessboards (see for example the beautiful A316667) and things of similar nature.
Anyway, you can try to derive your own stats, there are huge free game databases such as the Lichess CC0 database of billions of games from their server, as well as powerful free software engines allowing you to arrange and automatically play out hundreds of thousands of games. Why not take the chance?
{ TODO: Derive stats about the best move, i.e. for example "best move is usually by queen by three squares" or something like that. Could this actually help the play somehow? Maybe could be used for move ordering in alpha-beta. ~drummyfish }
Besides very similar games such as shogi there are many variants of chess with slight modifications of the rules, foremost worth mentioning is for example chess 960. The following is a list of some variants:
This subsection will be dedicated to various not well tested ideas.
{ I'll be pasting my ideas here. It's possible that these variants already exist and I just haven't found them. If you recognize something in this section as an existing variant, please let me know <3 ~drummyfish }
LRS chess: { This one seems quite obvious, it probably already exists? ~drummyfish } chess is only mildly bloated but what if we try to unbloat it completely? Here we propose the LRS version of chess. The rule changes against normal chess are:
{ I was thinking about a variant that would completely remove the white's first move advantage and here is my idea: let the players make the moves simultaneously. In real life this can be done for example by players writing the moves on a piece of paper, then revealing them. Of course we'd have to address conflicting situations such as both players moving their kings so that the new position would be illegal. Perhaps the turn would be successful only if the two moves performed in either order would result in the same, legal position. If the turn was unsuccessful, the attempt at a turn would repeat and let's say after 3 unsuccessful attempts the game would be a draw. ~drummyfish }
{ I got another idea for a chess variant, inspired by Warcraft 3: chess with races. It would be an extension of normal chess, in which each player could choose a "race" to play with. Races would differ by the initial setup on the player's side and the default "human" race would just have the traditional chess setup. Other races could be created by giving some kind of advantage for a disadvantage, e.g. having some men already developed for the price of one pawn -- this would probably have to be tuned with help of an engine so that all matchups would be balanced. It would also be possible to add new types of men or special abilities for the new races, but then we'd lose the ability to play this variant with traditional chess engines. ~drummyfish }
{ Another quick idea: lose against random moves (draw or victory equates loss). I literally haven't tried it, maybe it's going to be too boring or too easy, but I thought it might be good for beginners (and advanced players could potentially make it harder by imposing further restrictions, like lose in N moves or fewer, lose N games in a row, give the opponent material disadvantage etc.). The point was that this is a single player variant that's very easy to program, can even be played without a computer (dice) and it could be educational in some ways, mainly by making you think from the opponent's point of view. ~drummyfish }
Some general tips and rules of thumb, mostly for beginners:
see also unsportmanship
WORK IN PROGRESS, pls send me more tips :)
1. Qe9#.
gg, spam ez when you win. If he wins say it was a shit game and accuse him of cheating.
Color (also colour, from celare, "to cover") is the perceived visual quality of light that's associated with its wavelength/frequency (or mixture of several); for example red, blue and yellow are colors. Electromagnetic waves with wavelength from about 380 to 750 nm (about 400 to 790 THz) form the visible spectrum, i.e. waves our eyes can see -- combining such waves with different intensities and letting them fall on the retina of our eyes gives rise to the perception of color in our brain. Without a question colors play immensely important role in our daily lives and thus the study of such an essential physical quality is very profound: there is a deep and complex color theory concerned with the concept of color (its definition, description, reproduction, psychological effect etc.). Needless to say colors are intimately related to any visual information such as art, computer graphics, astrophysics, various visualizations or just everyday perception of our world. Color support is sometimes used as the opposite of systems that are extremely limited in the number of colors they can handle, which may be called monochromatic, 1bit (distinguishing only two colors), black&white or grayscale. Color can be thought of as having a similar relationship to visual information as pitch has to auditory information.
Fun fact: in the past some colors were officially called nigger.
How many colors are there? The total count of colors humans can distinguish is of course individual (color blindness makes people see fewer colors but there are also conditions that make some people be able to perceive more colors), then also we can ask what color really means (see below) but -- approximately speaking -- various sources state we are able to distinguish millions or even over 10 million different colors on average. In computer technology we talk about color depth which says the number of bits we use to represent color -- the more bits, the more colors we can represent. 24 bits are nowadays mostly used to record color (8 bits for each red, green and blue component, so called true color), which allows for 16777216 distinct colors, though even something like 16 bits (65536 colors) is mostly enough for many use cases. Some advanced systems however support many more colors than true color, especially extremely bright and dim ones -- see HDR.
What gives physical objects their color? Most everyday objects get their color from reflecting only specific parts of the white light (usually sunlight), while absorbing the opposite part of the spectrum, i.e. for example a white object reflects all incoming light, a black one absorbs all incoming light (that's why black things get hot in sunlight), a red one reflects the red light and absorbs the rest etc. This is determined by the qualities of the object's surface, such as the structure of its atoms or its microscopic geometry.
This is actually a non-trivial question, or rather there exist many varying definitions of it and furthermore it is a matter of subjective experience, perception of colors may differ between people (see for instance the infamous "gold/blue" dress meme). When asking what color really is, consider the following:
Provided it's so hard to even define color, it's no surprise that color theory is kind of complicated as fuck. This section will only poke on essential stuff, mostly in relation to programming.
To preface we must briefly mention that colors are divided in many ways, for example there are spectral colors (ones that can be describes by a single wavelength, i.e. those found in the rainbow), primary colors (a set of a few basic colors whose mixing can produce other colors, for example red, green and blue; this depends on color model), secondary colors (equal mixing of two primary ones), tertiary colors (mix of primary and secondary) etc.
How do our eyes perceive color? Even if by chance we hated biology, it's useful to know the basics of what's going on in our eyes and brains. In they eye (on the retina) we have two kinds of bitches (cells): rods and cones. Rods perceive "brightness", i.e. "how many photons per second" there are -- these bitches can't see color, only "intensity" of light, but they're useful at night when there is low light. Cones on the other hand make us see actual colors, and they are separated to three types: ones detecting red, green and blue light. Each type of cone gets excited when bombarded with photons of its respective desired FREQUENCY (i.e. color), and it also reacts a little less to frequencies close to that key frequency. So for example the "green color" cones react violently when a photon with the frequency of 555 * 10^12 Hz (wavelength of 540 nm) hits them, and they also somewhat react to 600 * 10^12 Hz, but they remain very chill when hit by 680 * 10^12 Hz wave -- but here the blue cone gets excited very much. The brain sees the amount of excitement for each of the three cone types and based on that decides what exact color we are seeing.
Now to begin with the programming theory, let's start with the term color model. As could be guessed by the name, it means "mathematical model of color", i.e. a way of representing colors with numbers. Even though this is probably not 100% correct, as programmers we can more or less equate color model with "color representation in memory". There exist several widely used color models, most of which consist of 3 numeric components. This means that color to us can be abstractly though of as a point in 3D space (unless we're dealing with more limited colors, for example shades of gray, which is then of course a 1 dimensional value). Color models can be further divided into additive, subtractive etc.
Let's list some of the most common color models/representations (conversions between then will be shown later):
Now given a model such as RGB, a mathematician will like to represent each of the components as a real number in the range between 0 and 1, i.e. for example the red color would be represented as [1,0,0]. As programmers, however, we'll eventually have to quantize the values and thus we have to also talk about so called color depth, a value saying how many bits we allocate for a color representation -- the term bits per pixel (BPP) is frequently encountered as a unit here. For example the standard for the RGB model is nowadays 8 bits per component, i.e. 24 bits in total, and so it is sometimes called RGB24 (this frequently gets extended to RGB32 by adding another 8bit alpha component, which expresses transparency; this is convenient as 32bit values nicely align in memory). 24bit RGB values are commonly expressed in hexadecimal where, very conveniently, each pair of digits represents one component: for example the color green might be written as #00ff00 (sometimes even shorter forms are allowed, e.g. CSS also supports #0f0). Color depth, naturally, will imply how many colors in total we'll be able to represent. Some devices possess higher color depth (see mainly HDR) and some have lower (e.g. RGB332 uses 8, RGB565 uses 16 etc.). In case we can't split the number of bits evenly, we should allocate more bits for the components that "matter more" in terms of human vision -- for example RGB565 allocates 5 bits to red and blue and 6 bits to green, as human eye is most sensitive to green. Especially with lower color depths tricks such as dithering can be used to visually simulate more colors.
Another essential term is color space, practically denoting a set of "physical" colors. Color space is oftentimes related to and/or confused with color model, but they are different things: whereas color model says how we represent color, color space just defines a set of colors in the real world. Color space may also define a correspondence with some specific color model(s), i.e. for example the color of the Sun in the sky may correspond to the RGB value [1.0, 1.0, 1.0] or something -- this is why they may get confused. There exist standardized color spaces such as sRGB. Colors spaces such as oklab aim for perceptual uniformity, e.g. that of lightness and hue. Then there also exists the term gamut which signifies a subset of given colorspace. Gamut is used in context of physical devices such as monitors, printers or cameras, to express which exact physical colors the device can reproduce and/or capture. Color spaces and gamuts are important when you're calibrating devices, for example if you want the colors on your monitor match colors that come out of your printer etc.
Finally let's quickly go over other concepts related to colors. Gamma correction is a non-linear function very often used on the "brightness" component of recorded colors -- this is because human sight is more sensitive to darker colors than lighter ones, and so to increase perceptual image quality it is good to allocate more bits for darker tones on the detriment of lighter ones. HDR (high dynamic range) means that a device is capable of handling "brightness" values in very wide range, i.e. for instance an HDR camera will be able to simultaneously capture details in both very bright and very dark areas of a scene (whereas in traditional cameras a bright sky will for example turn out all white) -- for this a very high color depth is used (typically the RGB components are represented as floating point values). Complementary color to given color is one that "cancels" it out when mixed with it.
The following is a table of some common colors (stage signifies an order in which colors usually develop in natural human languages):
| color name | red | green | blue | cyan | magenta | yellow | hue | chroma | sat.(V) | sat.(L) | value | light. | grayscale | RGB24 | RGB565 | RGB332 | stage | comment |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| white | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | ffffff | ffff | ff | 1 | all frequencies, complementary to black |
| light gray | 0.75 | 0.75 | 0.75 | 0.25 | 0.25 | 0.25 | 0 | 0 | 0 | 0 | 0.75 | 0.75 | 0.75 | c0c0c0 | c618 | db | complementary to dark gray | |
| gray | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0 | 0 | 0 | 0 | 0.5 | 0.5 | 0.5 | 808080 | 8410 | 92 | 6 | complementary to self |
| dark gray | 0.25 | 0.25 | 0.25 | 0.75 | 0.75 | 0.75 | 0 | 0 | 0 | 0 | 0.25 | 0.25 | 0.25 | 404040 | 4208 | 49 | complementary to light gray | |
| black | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 000000 | 0000 | 00 | 1 | lack of light, complementary to white |
| red | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0.5 | 0.29 | ff0000 | f800 | e0 | 2 | ~685 nm, RGB primary, complementary to cyan |
| orange | 1 | 0.5 | 0 | 0 | 0.5 | 1 | 0.08 | 1 | 1 | 1 | 1 | 0.5 | 0.59 | ff8000 | fc00 | f0 | 6 | ~605 nm, RGB tertiary, AKA light brown |
| azure | 0 | 0.5 | 1 | 1 | 0.5 | 0 | 0.57 | 1 | 1 | 1 | 1 | 0.5 | 0.44 | 0080ff | 041f | 13 | ||
| yellow | 1 | 1 | 0 | 0 | 0 | 1 | 0.16 | 1 | 1 | 1 | 1 | 0.5 | 0.88 | ffff00 | ffe0 | fc | 3 | ~580 nm, RGB secondary, complementary to blue |
| green | 0 | 1 | 0 | 1 | 0 | 1 | 0.33 | 1 | 1 | 1 | 1 | 0.5 | 0.58 | 00ff00 | 07e0 | 1c | 3 | ~532 nm, RGB primary, complementary to pink |
| cyan | 0 | 1 | 1 | 1 | 0 | 0 | 0.5 | 1 | 1 | 1 | 1 | 0.5 | 0.7 | 00ffff | 07ff | 1f | ~512 nm, RGB secondary, complementary to red | |
| blue | 0 | 0 | 1 | 1 | 1 | 0 | 0.66 | 1 | 1 | 1 | 1 | 0.5 | 0.11 | 0000ff | 001f | 03 | 4 | ~472 nm, RGB primary, complementary to yellow, most favorite in the world |
| violet | 0.5 | 0 | 1 | 0.5 | 1 | 0 | 0.75 | 1 | 1 | 1 | 1 | 0.5 | 0.26 | 8000ff | 801f | 83 | ~415 nm, RGB tertiary | |
| pink | 1 | 0 | 1 | 0 | 1 | 0 | 0.83 | 1 | 1 | 1 | 1 | 0.5 | 0.41 | ff00ff | f81f | e3 | 6 | RGB secondary, complementary to green |
| light red | 1 | 0.5 | 0.5 | 0 | 0.5 | 0.5 | 0 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.64 | ff8080 | fc10 | f2 | ||
| light orange | 1 | 0.75 | 0.5 | 0 | 0.25 | 0.5 | 0.08 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.79 | ffc040 | fe10 | fa | ||
| light yellow | 1 | 1 | 0.5 | 0 | 0 | 0.5 | 0.16 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.94 | ffff80 | fff0 | fe | ||
| light green | 0.5 | 1 | 0.5 | 0.5 | 0 | 0.5 | 0.33 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.79 | 80ff80 | 87f0 | 9e | ||
| light cyan | 0.5 | 1 | 1 | 0.5 | 0 | 0 | 0.5 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.85 | 80ffff | 87ff | 9f | ||
| light blue | 0.5 | 0.5 | 1 | 0.5 | 0.5 | 0 | 0.66 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.55 | 8080ff | 841f | 93 | ||
| light violet | 0.75 | 0.5 | 1 | 0.25 | 0.5 | 0 | 0.75 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.63 | c08040 | c41f | d3 | ||
| light pink | 1 | 0.5 | 1 | 0 | 0.5 | 0 | 0.83 | 0.5 | 0.5 | 1 | 1 | 0.75 | 0.7 | ff80ff | fc1f | f3 | ||
| dark red | 0.5 | 0 | 0 | 0.5 | 1 | 1 | 0 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.14 | 800000 | 8000 | 80 | ||
| brown | 0.5 | 0.25 | 0 | 0.5 | 0.75 | 1 | 0.08 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.29 | 804000 | 8200 | 88 | 5 | AKA dark orange, context sensitive (must be around lighter colors) |
| dark yellow | 0.5 | 0.5 | 0 | 0.5 | 0.5 | 1 | 0.16 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.44 | 808000 | 8400 | 90 | ||
| dark green | 0 | 0.5 | 0 | 1 | 0.5 | 1 | 0.33 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.29 | 008000 | 0400 | 10 | ||
| teal | 0 | 0.5 | 0.5 | 1 | 0.5 | 0.5 | 0.5 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.35 | 008080 | 0410 | 12 | AKA dark cyan | |
| dark blue | 0 | 0 | 0.5 | 1 | 1 | 0.5 | 0.66 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.05 | 000080 | 0010 | 02 | ||
| dark violet | 0.25 | 0 | 0.5 | 0.75 | 1 | 0.5 | 0.75 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.13 | c00080 | 4010 | 42 | ||
| purple | 0.5 | 0 | 0.5 | 0.5 | 1 | 0.5 | 0.83 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.2 | 800080 | 8010 | 82 | 6 | AKA dark pink |
| indigo | 0.3 | 0 | 0.5 | 0.7 | 1 | 0.5 | 0.75 | 0.5 | 1 | 1 | 0.5 | 0.25 | 0.18 | 4b0082 | 4810 | 42 |
Below is a C code implementing some functions for conversion between different color representations, may it serve as a reference of how to convert between them.
#define u8 unsigned char
u8 rgbToGray(u8 r, u8 g, u8 b)
{
// eye has diff. sens. to components, formula: gray ~= 0.3 R + 0.6 G + 0.1 B
return (5 * ((unsigned) r) + 8 * ((unsigned) g) + 3 * ((unsigned) b)) / 16;
// however this is still only approximate, the exact formula seems to be non-linear,
// see the article on RGB 332 to get a brightness-sorted list of colors
}
void rgbToCmy(u8 r, u8 g, u8 b, u8 *c, u8 *m, u8 *y)
{
*c = 255 - r; *m = 255 - g; *y = 255 - b;
}
void cmyToRgb(u8 c, u8 m, u8 y, u8 *r, u8 *g, u8 *b)
{
*r = 255 - c; *g = 255 - m; *b = 255 - y;
}
void hsvlToRgb(u8 h, u8 s, u8 vl, u8 *r, u8 *g, u8 *b, u8 hsv)
{
*r = hsv ? ((((int) vl) * s) / 256) :
(((int) (256 - 2 * ((vl > 127) ? (vl - 127) : (127 - vl)))) * s) / 256;
int c = (((((int) h) * 256) / 42) % 512) - 255;
*g = (((int) *r) * (255 + (c >= 0 ? -1 * c : c))) / 256;
*b = hsv ? (vl - *r) : (((int) vl) - *r / 2);
*r += *b;
*g += *b;
switch (h / 42)
{
case 0: break;
case 1: r ^= g; g ^= r; r ^= g; break; // swap
case 2: r ^= g; g ^= r; r ^= g; r ^= b; b ^= r; r ^= b; break;
case 3: r ^= b; b ^= r; r ^= b; break;
case 4: g ^= b; b ^= g; g ^= b; r ^= b; b ^= r; r ^= b; break;
default: g ^= b; b ^= g; g ^= b; break;
}
}
void rgbToHcsvl(u8 r, u8 g, u8 b, u8 *h, u8 *c, u8 *sv, u8 *sl, u8 *v, u8 *l)
{
int min = r < g ? (r < b ? r : b) : (g < b ? g : b); // min of 3
*v = r > g ? (r > b ? r : b) : (g > b ? g : b); // max of 3
*c = *v - min;
*l = (min + *v) / 2;
*sl = (*l != 0 && *l != 255) ?
((511 * (((int) *v) - *l)) / (256 - 2 * ((*l > 127) ?
(*l - 127) : (127 - *l)))) : 0;
min = *c;
*sv = (*v != 0) ? (255 * min) / *v : 0;
if (*c == 0)
*h = 0;
else if (*v == r)
*h = (256 + (42 * (((int) g) - b)) / min) % 256;
else if (*v == g)
*h = ((42 * ((2 * min + b) - r)) / min) % 256;
else if (*v == b)
*h = ((42 * ((4 * min + r) - g)) / min) % 256;
}
void hsvToRgb(u8 h, u8 s, u8 v, u8 *r, u8 *g, u8 *b)
{
hsvlToRgb(h,s,v,r,g,b,1);
}
void hslToRgb(u8 h, u8 s, u8 l, u8 *r, u8 *g, u8 *b)
{
hsvlToRgb(h,s,l,r,g,b,0);
}
void rgbToHsv(u8 r, u8 g, u8 b, u8 *h, u8 *s, u8 *v)
{
u8 sl, l, c;
rgbToHcsvl(r,g,b,h,&c,s,&sl,v,&sl);
}
void rgbToHsl(u8 r, u8 g, u8 b, u8 *h, u8 *s, u8 *l)
{
u8 sv, v, c;
rgbToHcsvl(r,g,b,h,&c,&sv,s,&v,l);
}
void rgbToHcv(u8 r, u8 g, u8 b, u8 *h, u8 *c, u8 *v)
{
u8 sv, sl, l;
rgbToHcsvl(r,g,b,h,c,&sv,&sl,v,&l);
}
void rgbToHcl(u8 r, u8 g, u8 b, u8 *h, u8 *c, u8 *l)
{
u8 sv, sl, v;
rgbToHcsvl(r,g,b,h,c,&sv,&sl,&v,l);
}
"When copying is outlawed, only outlaws will have culture." --Question Copyright website
Copyright (better called copyrestriction, copyrape or copywrong) is one of many types of so called "intellectual property" (IP), a legal concept that allows "ownership", i.e. restriction, censorship and artificial monopoly on certain kinds of information, for example prohibition of sharing or viewing useful information or improving art works. Copyright specifically allows the copyright holder (not necessarily the author) a monopoly (practically absolute power) over art creations such as images, songs or texts, which also include source code of computer programs. Copyright is a capitalist mechanism for creating artificial scarcity, enabling censorship and elimination of the public domain (a pool of freely shared works that anyone can use and benefit from). It is a mechanism that by definition smothers true, useful progress -- in a world that advanced technologically so much that it is already possible to freely copy and share information instantly, with zero cost, with anyone anywhere, copyright tries to set up artificial measures to prevent this so as to keep the old ways of allowing only the privileged to copy and publish intellectual works, it is quite literally force sustaining mechanism of Middle Ages. Copyright is not to be confused with trademarks, patents and other kinds of "intellectual property", which are similarly harmful but legally different. Copyright is symbolized by C in a circle or in brackets: (C), which is often accompanies by the phrase "all rights reserved".
When someone creates something that can even remotely be considered artistic expression (even such things as e.g. a mere collection of already existing things), he automatically gains copyright on it, without having to register it, pay any tax, announce it or let it be known anywhere in any way. He then practically has a full control over the work and can successfully sue anyone who basically just touches the work in any way (even unknowingly and unintentionally). Therefore any work (such as computer code) without a free license attached is implicitly fully "owned" by its creator (so called "all rights reserved") and can't be used by anyone without permission. It is said that copyright can't apply to ideas (ideas are covered by patents), only to expressions of ideas, however that's bullshit, the line isn't clear and is arbitrarily drawn by judges; for example regarding stories in books it's been established that the story itself can be copyrighted, not just its expression (e.g. you can't rewrite the Harry Potter story in different words and start selling it).
As if copyright wasn't bad enough of a cancer, there usually exist extra oppressive copyright-like restrictions called related rights or neighboring rights such as "moral rights", "personal rights" etc. Such "rights" differ a lot by country and can be used to restrict and censor even copyright-free works. This is a stuff that makes you want to commit suicide. Waivers such as CC0 try to waive copyright as well as neighboring rights (to what extent neighboring rights can be waived is debatable though).
The current extreme form of copyright (as well as other types of IP such as software patents) has been highly criticized by many people, even those whom it's supposed to "protect" (small game creators, musicians etc.). Strong copyright laws basically benefit mainly corporations and "trolls" on the detriment of everyone else. It smothers creativity and efficiency by prohibiting people to reuse, remix and improve already existing works -- something that's crucial for art, science, education and generally just making any kind of progress. Copyright absolutely devastates works of art with epidemic censorship, it increases the probability of any practically made work to be censored to a high level so works don't last for long, they die regularly: if you e.g. make a video, sooner or later you won't be able to share it because one of its many elements (music in it, sound effects, images, fonts, ...) will hit the copyright wall (your license runs out, you get a YouTube strike, author changes his mind about permission he has given, ...) -- this is convenient and needed for creating information consumerism that corporations need; to keep the business based on art consumerism it is necessary to keep removing old art, and copyright does this very well. Therefore despite most people still probably believing in "some" (much different) form of copyright, most also oppose the current extreme form which is absolutely crazy: copyright applies to everything without any registration or notice and last usually 70 years (!!!!!)) AFTER the author has died (!!!!!)) and is already rotting in the ground. This is 100 years in some countries. In some countries it is not even possible to waive copyright to own creations -- just think about what kind of twisted society we are living in when it PROHIBITS people from making a selfless donation of their own creations to others. Some people, including us, are against the very idea of copyright (those may either use waivers such as CC0 or unlicense or protest by not using any licenses and simply ignoring copyright which however will actually discourage other people from reusing their works). Though copyright was originally intended to ensure artists can make living with their works, it has now become the tool of states and corporations for universal censorship, control, bullying, surveillance, creating scarcity and bullshit jobs; states can use copyright to for example take down old politically inconvenient books shared on the Internet even if such takedowns do absolute not serve protection of anyone's living but purely political interests.
Prominent critics of copyright include Lawrence Lessig (who established free culture and Creative Commons as a response), Nina Paley and Richard Stallman. There are many movements and groups opposing copyright or its current form, most notably e.g. the free culture movement, free software movement, Creative Commons etc.
The book Free Culture by Lessig talks, besides others, about how copyright has started and how it's been shaped by corporations to becoming their tool for monopolizing art. The concept of copyright has appeared after the invention of printing press. The so called Statute of Anne of 1710 allowed the authors of books to control their copying for 14 years and only after registartion. The term could be prolonged by anothert 14 years if the author survived. The laws started to get more and more strict as control of information became more valued and eventually the term grew to life of author plus 70 years, without any need for registration or deposit of the copy of the work. Furthermore with new technologies, the scope of copyright has also extended: if copyright originally only limited copying of books, in the Internet age it started to cover basically any use, as any manipulation of digital data in the computer age requires making local copies. Additionally the copyright laws were passing despite being unconstitutional as the US constitution says that copyright term has to be finite -- the corporations have found a way around this and simply regularly increased the copyright's term, trying to make it de-facto infinite (technically not infinite but ever increasing). Their reason, of course, was to firstly forever keep ownership of their own art but also, maybe more importantly, to kill the public domain, i.e. prevent old works from entering the public domain where they would become a completely free, unrestricted work for all people, competing with their proprietary art (who would pay for movies if there were thousands of movies available for free?). Nowadays, with coprporations such as YouTube and Facebook de-facto controlling most of infromation sharing among common people, the situation worsens further: they can simply make their own laws that don't need to be passed by the government but simply implemented on the platform they control. This way they are already killing e.g. the right to fair use, they can simply remove any content on the basis of "copyright violation", even if such content would normally NOT violate copyright because it would fall under fair use. This would normally have to be decided by court, but a corporation here itself takes the role of the court. So in terms of copyright, corporations have now a greater say than governments, and of course they'll use this power against the people (e.g. to implement censorship and surveillance).
Copyright rules differ greatly by country, most notably the US measures copyright length from the publication of the work rather than from when the author died. It is possible for a work to be copyrighted in one country and not copyrighted in another. It is sometimes also very difficult to say whether a work is copyrighted because the rules have been greatly changing (e.g. a notice used to be required for some time), sometimes even retroactively copyrighting public domain works, and there also exists no official database of copyrighted works (you can't safely look up whether your creation is too similar to someone else's). All in all, copyright is a huge mess, which is why we choose free licenses and even public domain waivers.
Not even lawyers have any clue about copyright in all its complexity, it's so hugely complicated by now that apart from very clear cases no one can usually safely tell you what's copyrighted and what not, it's not defined clearly, different countries have different rules and precedents and if you win a copyright court case or not depends many times on who the judge is, whether he got laid that night and if he took a good shit in the morning. The moral of the story is this: KEEP IN THE SAFE ZONE, never go to copyright gray areas, make everything yourself from scratch, minimize reusing someone else's works.
Copyright does cultural harm as well: for example it tightly connects people with ideas and art, their "property", and extorts a force against attempts at separating humans from ideas, which is necessary for critical evaluation of ideas. While past philosophers correctly saw art as rather being discovered than created, as when we're discovering new land or laws of nature, copyright removes any subconscious humility, it makes man into a god who CONJURES a thing, owns it, controls it and has absolute authority over it, further fueling the extinction of humble individuals. If now someone discovers a new way of arranging colors on a canvas so that it pleases human eye, people see it as "logical" that he can forbid anyone from doing it or demand money wherever this arrangement appears. It is not logical at all, but it now seems logical -- the power of evil is unlimited and can bend even logic.
In some countries copyright terrorists already establishes a kind of tax that is paid when buying a storage device such as a USB stick -- it is now assumed the device will be used to share copyrighted material so you pay extra money in advance to copyright holders for this crime you are found guilty of before you commit it. Welcome to 21st century.
Copyleft (also share-alike) is a concept standing against copyright, a kind of anti-copyright, invented by Richard Stallman in the context of free software. It's a license that grants people the rights to the author's work on the condition that they share its further modification under the same terms, which basically hacks copyright to effectively spread free works like a "virus".
Copyright does not (or at least should not) apply to facts (including mathematical formulas) (even though the formulation of them may be copyrighted), ideas (though these may be covered by patents) and single words or short phrases (these may however still be trademarked) and similarly trivial works. As such copyright can't e.g. be applied to game mechanics of a computer game (it's an idea). It is also basically proven that copyright doesn't cover computer languages (Oracle vs Google). Also even though many try to claim so, copyright does NOT arise for the effort needed to create the work -- so called "sweat of the brow" -- some say that when it took a great effort to create something, the author should get a copyright on it, however this is NOT and must NOT be the case (otherwise it would be possible to copyright mere ideas, simple mathematical formulas, rules of games etc.). Depending on time and location there also exist various peculiar exceptions such as the freedom of panorama for photographs or uncopyrightable utilitarian design (e.g. no one can own the shape of a generic car). But it's never good to rely on these peculiarities as they are specific to time/location, they are often highly subjective, fuzzy and debatable and may even be retroactively changed by law. This constitutes a huge legal bloat and many time legal unsafety. Do not stay in the gray area, try to stay safely far away from the fuzzy copyright line.
A work which is not covered by copyright (and any other IP) -- which is nowadays pretty rare due to the extent and duration of copyright -- is in the public domain.
Free software (and free art etc.) is not automatically public domain, it is mostly still copyrighted, i.e. "owned" by someone, but the owner has given some key rights to everyone with a free software license and by doing so minimized or even eliminated the negative effects of full copyright. The owner may still keep the rights e.g. to being properly credited in all copies of the software, which he may enforce in court. Similarly software that is in public domain is not automatically free software -- this holds only if source code for this software is available (so that the rights to studying and modifying can be executed).
Copyright encourages murder. The sooner the author dies, the sooner his material will run out of copyright, so if you want some nice work to enter public domain soon, you are literally led by the law to try for him to die as soon as possible.
A commonly used trick for legally bypassing copyright restrictions is to use patches. It can help legally modify proprietary works and distribute these modifications by publishing ONLY the changes without redistributing the copyrighted work along. Say there is for example a proprietary video game with ads in it and some good programmer decides to modify the game and remove the ads -- like a good human he would subsequently like to share this modified game with others to spare them of suffering from the advertisement torture, but he can't publicly upload the modified version anywhere because it's a derivative work (a modification of something "owned" by someone else), the copyright belongs not to him but to the game company and that can order an instant takedown of this version and even punish the uploader with a lawsuit. What he can do instead is to publish only a patch, a set of changes that can be automatically applied to the original game to create the modified ad-free version. This patch can legally be distributed because it's technically not a derivative work, it's an original code not containing the game, it's just a set of instruction saying how to remove ads from the video game. To obtain the modified ad-free version it is therefore necessary to already own the original version, but this is still a better situation than not being able to have an ad-free video game at all. This technique works very well and patches are even a very elegant way of sharing that saves bandwidth and storage, but it's true there may be some potential hurdles we have to watch for. For instance the patch MAY sometimes end up legally constituting a derivative work -- imagine for example a fan-fiction patch that can be applied to a Harry Potter book to obtain a longer, more detailed version of the book; this specific patch will probably have to carry with it new text that contains copyrightable elements such as characters and parts of the original plot. So in summary patches are awesome in bypassing some restrictions, but ultimately do not solve the copyright problem.
DISCLAIMER: Fuck you.
NO ONE EXCEPT DRUMMYFISH UNDERSTANDS COPYRIGHT for some reason, not even copyright lawyers, judges, people with 10 Nobel prizes in law and people dealing with copyright for their whole lives, it's incredible how people somehow cannot grasp the basic idea of copyright. It is a bit more complex than wiping your butt but it's not rocket surgery, for some reason everyone keeps coming up with weird conspiracy theories about how copyright works when there are relatively simple rules that allow us to analyze every single case exactly, save for subjective judgments such as where the threshold of originality lies etc. Here is an attempt at dumbing it all down to a simple summary that anyone with half a brain can hopefully follow.
Preface: we must reiterate that copyright is NOT the only form of intellectual property, there are many others (trademarks, patents, personal rights, trade dress, ...). Here we will focus on copyright because that's usually what causes us trouble, but even if we check that copyright isn't burdening a specific work, it's still possible it will be burdened by another shit, always keep this on your mind. Also copyright laws differ by country etcetc., you know the drill.
Next, STOP ASSUMING WEIRD COMMON SENSE THEORIES, that's not how law works, law is not about common sense or feelings or fairness or justice or morality or anything else but completely arbitrary rules established by drunk idiots for fun which must be followed absolutely blindly even if it makes zero sense because we live in a dystopia full of idiots who do fucked up shit. To understand copyright you must first understand this as reality, copyright doesn't work as you would wish or assume it worked. To understand copyright just learn the rules and don't ask why they are so because if we wanted to be reasonable, first of all we'd get rid of whole copyright altogether. Some shit theories people often come up with include:
Now suppose we have an intellectual work W, such as a picture, video game, an invented word, circuit schematic, sound effect, logo, music, font, book, fictional character, book translation, mathematical formula, language, a collection of quotes by famous people and so on -- anything that's a non-physical work, anything that can by any stretch be considered a creative art requiring some intellectual "work", i.e. thinking, intuition, creativity etc. Of course this intellectual work MAY be mixed in with a physical work (for example a painting will be PHYSICALLY present on a canvas, or a car design will be present on a PHYSICAL car) -- here we must see that these are two works connected together: the intellectual work and the physical work. There is no issue here, we are still dealing with intellectual work, even if it's only a part of something that's inherently a combination of the abstract and the physical.
Now let's examine the intellectual work's status in terms of copyright. Again, we will now make a simplification (that often holds in practice, but not always) and suppose the work is NOT further burdened by other intellectual property such as patents or trademarks, so we're assuming that the only form over the work W that can now be present is copyright. We'll ask who holds the copyright, if the work is free etc.
Who has the copyright over work W (i.e. who "owns" it)? If the work is copyrightable (see below), then that who created it (even multiple people or a company etc.) automatically has the copyright (without registering it or declaring it or anything, also note that sometimes the creator sells the copyright to someone else, e.g. a recording studio, and so transfers the copyright to someone else), UNLESS the work is a derivative work of some already existing copyrighted work, in which case the creator of the original work has the copyright on the "copied" parts while the creator of the new work has copyright over the independent, newly added parts only. Derivative work PRACTICALLY means that the work was "not created from scratch", i.e. that it is rather a modification of something else and so that who created it can't own it as a whole, it contains something "owned" by someone else -- for example a fan fiction of Harry Potter is a derivative work because it's heavily based on an existing copyrighted work of Harry Potter, so the owner of Harry Potter now also own parts of all Harry Potter fan fictions, ok? However anything "completely new and original" (such as a completely new invented character) that was added to the original work can SEPARATELY be considered an original work owned by the creator of the derivative work (the fanfiction). Makes sense, right? There is a (sometimes quite subjectively drawn) fine line between a derivative work and a work merely lightly inspired by something that already exists, the latter of which is NOT considered a derivative work: no one can really tell you where the line is exactly, but a basic helper is asking for example "Am I only borrowing trivial, non-copyrightable parts of an existing work?" -- for example borrowing a name of a fantasy race from an existing work may be fine because words are non-copyrightable (but again, if you borrow too many of them it may be a violation because a collection or a whole terminology may already be considered a non-trivial work). Also ask this: if my work were to be judged a derivative work of another work, what consequences would it have? For example if a court judged that you borrowing names of fantasy races from Harry Potter was more than just mere inspiration, then they would also have to admit that the author of Harry Potter was also violating other older works (such as Lord of the Rings) in exactly the same way and so can't have copyright on them, so me doing so is most likely OK, the author can't (well, shouldn't able to) sue me for doing X if his work alone (and furthermore basically 99% of all other existing works) is based on the assumption that X is legal.
Important note: the status of derivative work is only based on similarity. Derivative work is defined simply as a work that is "too similar" to an already existing work, it doesn't matter at all if you LITERALLY made your work based on something or if you accidentally made something too similar to something that already exists because proving HOW the work was made is impossible, it is assumed that if you make something too similar to something else (which is older), it couldn't have happened by chance (even if there is a non-zero probability of it being possible and even if you could prove you made it independently), there would be a mess of two conflicting copyrights and shit, it will just be declared you copied the work even if you didn't and everyone knows it, it's just the rules. So don't try any tricks here. Imagine the world of intellectual works literally as a land: if someone creates something, he basically farms a piece of unoccupied land and by that starts owning it, and along with it also some NEARBY AREA he didn't farm yet (the land of derivative works) -- no one can simply use that nearby area without his permission, no matter by what way he gets there (intentionally or accidentally, in good faith or not), the original farmer simply owns the land by the virtue of having farmed a nearby land first. Again it's a mega retarded rule but it's the rule that exist because without it copyright couldn't work (anyone would be able to bypass copyright by just changing a single pixel in a picture for example).
Examples of derivative works are:
So yes, a work can have MULTIPLE copyright holders: it may be that different (even overlapping) subparts of the work are "owned" by different people or that the whole is owned by multiple people etc.
Now let's ask this: Is the work W libre (free as in freedom)? Spoiler: If the work has a free license, it is not necessarily free!* Currently based on observations it may be that let's say only 70% of works with a free license you will find on the Internet are ACTUALLY free. In theory a free license should imply a free work, but in practice this is just not so, just like for example an "eco" label doesn't automatically mean something is eco-friendly, it's simply a sticker that became either misused or downright abused, so you cannot rely on a sticker, even the forefront "free content" websites often distribute non-free works under free licenses. It's probably not even that the guy who illegitimately puts a free license on his work is doing something illegal, it may be completely legal to do (if you read the license carefully, you may find it states that it only applies to what the author actually created), the point is that the license is likely ineffective (or only partially effective, not applied to the work as a whole, just to some parts), so you may get into legal trouble by using such works in ways you think you are allowed to but in fact aren't. People just stick the licenses on works without knowing how copyright works AND some purposefully use ineffective free licenses as a form of openwashing -- the best example is probably Wikipedia which is popularly known as the "free" encyclopedia and while it's true that a great part of it IS free, it's also true a great deal of it simply is NOT truly free (for example the free use images or detailed plot summaries of proprietary movies -- yes, it is LEGAL but it's not free, we'll explain this later on). Same with Linux etc. Remember that a free license can be put on anything, you can write anything on a piece of paper, nothing will happen even if you download a 100% proprietary Hollywood movie and put a CC0 on it, the world will not explode -- only when it starts to cause the copyright holder significant financial losses to be worth it for him to sue you and drag through months or years of court battles will you learn that in fact the license was ineffective, but this will almost never happen, there are millions and millions of "fake free" works on the Internet that no one cares about because in 99% cases they don't harm anyone's wallet, and because they keep happily existing like this thanks to being tolerated (despite not being legit), a common public perception arose that it's actually legitimate to use licenses like this, but it's nothing but a myth, a misconception widely believed even by many people "in the business".
Not to digress, let's reiterate the definition of a libre (free) work: if a work is to be libre, it must PRACTICALLY grant the basic four freedoms: to use, study, modify and share. Now the key here is NOT to just look at legal rights but rather ask about de facto freedom, i.e. don't ask whether it's written somewhere you can do something with that work, firstly ask whether you REALLY can do it practically. Literally ask yourself questions such as: "Can I now go and modify this work in any way I want? Or am I prevented from doing so, e.g. by not having any available tools for it or the source code literally not being available for download anywhere?". If on paper it says you can modify the work but then in practice you can't because the source code is obfuscated, you DO NOT have the right practically and therefore the work is NOT free (at best you can argue it is free legally without being free practically, which is the same as e.g. being legally alive while actually being physically dead). If you find you don't have even just one of the basic four freedoms de facto available, the work is NOT free. But if it passes the test, we can move on.
Now a prerequisite (but, as we said, NOT a sufficient condition) for the main, practical freedom is that you also must have these basic four freedoms granted LEGALLY, because in today's world any work is by default owned by someone and if you don't get explicit permission to do something with it, you may get legally bullied which eventually results in you PHYSICALLY becoming unable to utilize the freedoms (as you'll end up in jail and your work will be burned etc.), and so here is where we start to check the licenses and stuff. So as a next step we have to take a look at the legal side: ask yourself "Can I legally exercise ALL of the four basic freedoms?". You can if:
Now this is the key part: in your copyright analysis you MUST always also consider ALL subparts of the work and any possible combination and modification thereof AND any possible use (even nonsensical, unethical etc.). This is what people often don't realize, they think that as long as we take a libre work and do only legal things with, it will remain libre, and that's a 100% FATAL MISTAKE: being libre is a MORE STRICT attribute than being legal, it is something extra, not necessarily guaranteed by legality (even proprietary software is legal), and adding something legal to a free work can make it non-free. You must always ask yourself questions such as: "If I cut out this part of the work, can I do anything with it? Can I extract the font from this work and start selling it?" This is part of the modification and redistribution freedom and it must always be unlimited, else the work isn't libre. You cannot argue like "Who would want to extract font from my game just to sell it? That's a weird use and I don't want people to do it." -- the basic part of the definition of a free cultural work is to allow ANY kind of use, including that which doesn't make sense or which the author is against. If you want to disallow certain uses of your work you (sadly) can, simply by using a non-free license, but you CANNOT claim your work is free if you do this. So remember: even if it's legal, it's not necessarily libre. -- really this is possibly a NUMBER ONE mistake people make. They think that if they can legally include something under fair use or with permission in their libre game, the game will remain libre. It will NOT! This is because now the work doesn't allow anyone to do anything with it as fair use limits what can be done with the work, typically disallowing for example commercial use: so if you have a fair use asset in your game, it is now IMPOSSIBLE to cut out that asset and start selling it, and therefore the work is NOT LIBRE (even though the work in its form is still legal). Ask yourself another hypothetical question: "If I send this work to an alien who won't have access to any other works besides the one I sent, WILL HE BE ABLE (omitting unreasonably miraculously improbable cases) to recreate a proprietary work from this if he wants?" If your work is to be considered TRULY libre, the answer must be NO. A libre work must guarantee that if someone takes it and randomly messes with in any way (without mixing in other works of course), it won't suddenly become proprietary. I.e. for example the Wikipedia's article about Harry Potter is NOT truly libre because if I send the page to an alien, he can take the plot summary and expand it a little bit to a book that will be too similar to the original Harry Potter book, violating its copyright, which means the Wikipedia article doesn't permit any kind of modification due to relying on fair use, the essential freedom of modification is limited because in order for the article to stay legally safe it must remain unmodified or can be modified in only limited ways -- expanding the plot summary into a whole book is not allowed, and so the article is not free/libre. Another example: there is for example so called "freedom of panorama" rule that says you can use photographs of buildings that contain copyrightable elements as a part of wide panorama BUT here is the catch: such photograph cannot be free as in freedom because modification is limited here by the inability to crop the building out -- then freedom of panorama would cease to apply, so cropping the picture is forbidden. Do you fucking understand it now? I know you wish it wasn't so but you goddamn bet it is so, we live in a shittopia, don't mistake your wishful thinking for reality.
{ Check out our cool CSS styles in the wiki consoomer edition. ~drummyfish }
Cascading Style Sheets (CSS, cascading because of the possible style hierarchy) is a computer language for styling documents (i.e. defining their visual appearance), used mainly on the web for giving websites (HTML documents) their look. The language is standardized by W3C (the consortium established for making such standards). CSS is NOT a programming language, it's merely a language that defines attributes of visual presentation such as "headings should use this font" or "background should have this color"; it is one of the three main languages a website is written in: HTML (for writing the document), CSS (for giving the document a specific look) and JavaScript (programming language for the website's scripts). As of 2024 the latest CSS specification is version 2.1 from 2016, version 3 is being worked on.
A website is not required to have a CSS style, without it it will just have the plain default look (which is mostly good enough for communicating any information, but won't impress normies), though only boomers and hardcore minimalists nowadays have websites without any CSS at all (and we applaud them for such minimalism). Similarly a single HTML website may use several styles or allow switching between them -- this is thanks to the fact that the style is completely separate from the underlying document (you can in theory take any document's style and apply it to any other document) AND thanks to the overriding rules that say which style will take precedence over which (based on which one is more specific etc.) -- using multiple style sheets at once creates the "cascades" the name refers to. In theory a web browser may even allow the user to apply his own CSS style to given website (e.g. a half blind guy may apply style with big font, someone reading in dark will apply "dark mode" style and so on), though for some reason browsers don't really do this (well, it seems like the original intent of being able to do good things like this was reworked by capitalists that rather see CSS more as a tool to apply more marketing styling and, of course, a capitalist won't want the user to change how his site looks because he might for example hide ads or annoying flashing buttons the capitalist paid hard money for).
CSS was probably designed by a woman because there are 140 colors with individual names such as "Blanched Almond", "Coral" and "Misty Rose". However none named nigger.
Back in the boomer web days -- basically before the glorious year 2000 -- there was no CSS. Well, it was around, but support was poor and no one used it (or needed it for that matter). People cared more for sharing information than pimping muh graphics. Sometimes people needed to control the look of their website to some degree though, for example in an image gallery it's good to have thumbnail sizes the same, so HTML itself incorporated some minimal means to manipulate the looks (e.g. the width property in the img tag). People also did hacks such as raping tables or spamming the <br /> tags or using ASCII art to somehow force displaying something how they wanted it. However as corporations started to invade the web, they naturally wanted more consumerism, flashing lights and brainwas... ummm... marketing. They wanted to redefine the web from "collection of interlinked documents" or a "global database" to something more like "virtual billboard space" or maybe "gigantic electronic shopping center", which indeed they did. So they supported more work on CSS, more browsers started to support it and normies with blogs jumped on the train too, so CSS just became standard. On one hand CSS allows nice things, you can restyle your whole website with a single line change, but it is still bloat, so beware, use it wisely (or rather don't use it -- you can never go wrong with that).
Correct, LRS approved attitude towards this piece of bloat: as a minimalist, should you avoid CSS like the devil and never use it? Usual LRS recommendations apply but, just in case, let's reiterate. Use your brain, maximize good, minimize damage, just make it so that no one can ever say "oh no, I wish this site didn't have CSS". You CAN use CSS on your site, but it mustn't become any burden, only something optional that will make life better for those using a browser supporting CSS, i.e. your site MUSTN'T RELY on CSS, CSS mustn't be its dependency, the site has to work perfectly fine without it (remember that many browsers, especially the minimalist ones not under any corporation's control, don't even support CSS), the site must not be crippled without a style, i.e. firstly design your site without CSS and only add CSS as an optional improvement. Do not make your HTML bow to CSS, i.e. don't let CSS make you add tons of divs and classes, make HTML first and then make CSS bow to the HTML. Light CSS is better than heavy one. If you have a single page, embed CSS right into it (KISS, site is self contained and browser doesn't have to download extra files for your site) and make it short to save bandwidth on downloading your site. Don't use heavy CSS features like animation, blurs, color gradients or wild positioning, save the CPU, save the planet (:D). Etcetc.
PRO TIP: you can achieve some basic formatting completely without CSS (i.e. even without the style attribute) -- for some stuff you can use the old HTML visual attributes, even thought they are "discouraged". Whether it's better to do it this way or rather use CSS depends on situation, but it's good to have a choice, this may allow you to just completely avoid CSS (e.g. enter the "nocss" website club) and maybe have better chance of supporting ancient browsers. Though some of the attributes are already deprecated in HTML5, browsers still support them and the worst that can happen is that they simply won't work. It's probably also possible to use CSS and the HTML attributes together, as a fallback. The visual attributes include bgcolor, border, color, cols, height, rows, shape, size, width etc. You can also use tables to give the page a layout (this is how it used to be done back in the day). And of course you may use images for visuals as well, but that may already be an inferior, more bloated solution.
TODO: more more more
The CSS style can be put into three places:
<link rel="stylesheet" href="style.css">). This is good if you have multiple HTML files (i.e. a whole website) that use the same style.
<p style="color: red;"> hello </p>), but this is discouraged as we're once again intermixing definition of structure and visual style, something that CSS wanted to eliminate in the first place.The style itself is quite simple, it's just a list of styling rules, each one in format:
selectors
{
style
}
Here selectors say which elements the rule applies to and style defines the visual attributes. For example
p
{
color: blue;
font-size: 20px;
}
h1, h2, h3
{
color: red;
}
introduces two rules. One says that all p tags (paragraphs) should have blue text color and font that's 20 pixels tall. The second rule says that h1, h2 and h3 tags (headings) should have red text color. Pretty simple, no?
Tho it can get more complex, especially once you start positioning and aligning stuff (and making it all work on different devices and so on) -- it takes a while to learn how it all works, sometimes you'll encounter quite unintuitive design (for example that center-aligning a fixed-size block is not done with align attribute but rather through margin: auto). In the end it's not a rocket science, but you won't master CSS overnight. A general advice must be given: less is more, keep it simple!* Try to use only light CSS and a few simple rules, do not go apeshit with the latest and coolest bleeding edge CSS transformations and animations and whatnot, that will only make your site unmaintainable, bloated, slow, incompatible and most likely also annoying. CSS can do a lot and it's tempting to do crazy shit -- if you want something to be 3D spinning and have round corners and be positioned with absolute coordinates, you can do it, but it's not a good idea, please trust this advice.
TIP: "Modern" bloated web browser will typically have built-in so called "dev tools" (often opened with F12) that let you examine any website "under the hood", including visualization of all the CSS blocks and letting you modify them temporarily and in real time. This can help understand CSS much faster.
Now with CSS under our belt it's important to learn about two essential HTML elements we'll sooner or later come to need quite a lot:
<span>: A universal "inline" container. Unlike elements like for example <b> and <p>, span has no meaning from HTML's point of view, it "does nothing", but it's useful for styling. By default span has no distinct style either, it won't affect visual appearance in any way until we explicitly tell it to. We use spans to mark inline things (usually text) so that we can select them with CSS selectors. Let's say we'd like to for instance be able to highlight text on our site with yellow or green colors -- in our CSS style we'll add rules .yellow { background-color: yellow; } .green { background-color: green; } and then to actually highlight something we'll be using spans as so: <p> This is a paragraph. <span class="yellow"> This text is yellow-highlighted. </span> <span class="green"> And this is green. </span> </p>.
<div>: A universal "block" container. This is the same as span, with the difference that div is a block element, i.e. it's not part of the text flow. These are used for things such as navigation menus, images, video players and so on.It's understandable that a newbie digging through complete documentation of all existing CSS attributes will only end up with a frustrating information overload, and so let us help by picking some of the most important attributes you should check out to start with:
background-color: Color of the element's background, e.g. background-color: blue.
background-image: Sets an image as the element's background, e.g. background-image: url("images/goatse.jpg"). To further adjust HOW the image is applied see background-repeat, background-size, background-position etc.
border: Sets how the element's border is drawn (by default there's usually no border at all). For example: border: 1px dotted black. Borders on individual sides can separately be handled through border-top, border-right etc.
color: The color of TEXT (i.e. NOT the color of background, as intuition might suggest).
display: How to draw the element, most common values: none (invisible), inline (element that "flows in the text") or block (element outside text).
font-family: Chooses text font. The value is a comma-separated list of fonts that will be prioritized from the left, i.e. if desired font is missing, the right one will be tried and so forth. Besides concrete fonts ("Times New Roman", "Helvetica", ...), generic families can (and SHOULD) also be given, such as "sans-serif", "monospace", ... For example: font-family: Arial, Helvetica, sans-serif.
font-size: Size of text, e.g. font-size: 10pt.
height: Sets height of the element. See also min-height and max-height.
margin: Sets the gap that will be between this element and other elements, i.e. the OUTSIDE gap. This is similar to padding, but padding is for the inside of the element. Margin can be set for each direction (top, right, bottom and left) -- see attribute values below. IMPORTANTLY: setting both left and right margin to auto will make the element get aligned in the center (it will automatically position itself so that the left and right gaps are equal).
padding: Similar to margin, but sets the gap that's between the element's border and its INSIDE content.
text-align: How text will be aligned inside its parent, most common values: left, right, center or justify (kinda "block align", the text will be stretched to fill the whole block).
text-decoration: How the text is decorated, common values: none, underline, overline, line-through, ...
width: Like height but for width.Now the values of these attributes can very often be expressed in various formats, for example colors can be specified with RGB, hex values or English words. Here is a summary of value formats:
auto (compute automatically, as in width: auto), inherit (inherit the value from parent) and so on. Some attributes expect special keywords, e.g. text-decoration can be set to underline, overline, none etc.
px, as in width: 160px), points (pt, as in width: 20pt) and percents (of the parent's size, %, as in width: 50%).
color: rgb(255,0,127), rgba is allowed too), HSL (e.g. color: hsl(55, 30%, 50%)), hexadecimal (e.g. color: #00ff37 or color: #fc9) or plain English (e.g. color: red).
margin: 10px 20px 30px 40px means 10px on top, 20px right, 30px at the bottom and 40px left. If we'd do margin: 5px auto, we'd get 5px on top and bottom and auto on left and right. If we'd do margin: 10%, we'd get 10% in all directions, and so on. It's also possible to expand the attribute with the direction's name, like: margin-left: 10px.Some more advanced attributes to study next are float (can make page elements gravitate left or right), clear (related to float, says if the element should "wait" and be displayed only after float elements) and position (related to left, right, top and bottom attributes).
Oh dear, that's not nearly everything. Next check out pseudo elements and pseudo classes. For example .mydiv:hover will match anything with class mydiv, but ONLY if the mouse cursor is over it. p:first-child will select only those p elements that are first children of their parents. And so on and so forth.
TODO: moar
A user running bloatbrowser that implements CSS and has it turned on by default is openly inviting you to freely remotely manipulate what his computer is showing to him, so let's take this opportunity to do some lighthearted trolling :) Here are some possible approaches:
cursor: Change or even hide the mouse cursor :D You can set it to none (hide), progress (make the user think something's loading indefinitely, see how long it takes for him to realize), wait, col-resize or even specific image with url(...).
body * { display: none; } body:before { content: "This site only works without CSS." }.
@keyframes lul { 0% { background-color: red; } 100% { background-color: green; } } body { animation-name: lul; animation-duration: 0.1s; animation-iteration-count: infinite; }.
<body> size so that the scroll bars keep resizing.
a:hover { display: none; }: Makes links disappear when they're pointed at with the cursor :D Can also be used for buttons etc.
:hover, or better yet use transform to rotate or skew it, triggering a spectacular domino effect. You have to make it so that if one div reshapes on mouse over, another one gets under the cursor, triggering reshape of that one, which pushes another one under the cursor etc.
:hover, this will cause some vomit inducing blinking whenever mouse is moved.
Distance is a measure of how far away from each other two points are. Most commonly distance refers to physical separation in space, e.g. as in distance of planets from the Sun, but more generally distance may refer to any kind of parameter space and in any number of dimensions, e.g. the distance of events in time measured in seconds (1D distance) or distance of two text strings as the amount of their dissimilarity (Levenshtein distance). Distances are very important in computer science and math as they allow us to do such things as clustering, path searching, physics simulations, various comparisons, sorting etc.
Distance is similar/related to length, the difference is that distance is computed between two points while length is the distance of one point from some implicit origin. I.e. distance is computed between two vectors while length is computed from just one vector.
There are many ways to define distance within given space. Most common and implicitly assumed distance is the Euclidean distance (basically the "straight line from point A to point B" whose length is computed with [ Euclidean Theorem](euclidean_theorem.md)), but other distances are possible, e.g. the taxicab distance (length of the kind of perpendicular path taxis take between points A and B in Manhattan, usually longer than straight line). Mathematically a space in which distances can be measured are called metric spaces, and a distance within such space can be any function dist (called a distance or metric function) that satisfies these axioms:
dist(p,p) = 0 (distance from identical point is zero)
dist(p,q) > 0 if p != q (distance between two distinct points is always positive)
dist(p,q) = dist(q,p) (symmetry, distance between two points is the same in both directions).
dist(a,c) <= dist(a,b) + dist(b,c) (triangle inequality)Computing Euclidean distance requires multiplication and most importantly square root which is usually a pretty slow operation, therefore many times we look for simpler approximations. Note that a possible approach here may also lead through computing the distance normally but using a fast approximation of the square root.
Two very basic and rough approximations of Euclidean distance, both in 2D and 3D, are taxicab (also Manhattan) and Chebyshev distances. Taxicab distance is an upper bound on Euclidean distance (i.e. it's always greater than or equal to Euclidean distance) and is computed by merely adding the absolute coordinate differences along each principal axis (dx, dy and dz) while Chebyshev, a lower bound on Euclidean distance, takes the maximum of them (NOTE: taking minimum isn't possible due to the definition which requires two distinct points to always have positive distance). In C (for generalization to 3D just add one coordinate of course):
int distTaxi(int x0, int y0, int x1, int y1)
{
x0 = x1 > x0 ? x1 - x0 : x0 - x1; // dx
y0 = y1 > y0 ? y1 - y0 : y0 - y1; // dy
return x0 + y0;
}
int distCheb(int x0, int y0, int x1, int y1)
{
x0 = x1 > x0 ? x1 - x0 : x0 - x1; // dx
y0 = y1 > y0 ? y1 - y0 : y0 - y1; // dy
return x0 > y0 ? x0 : y0;
}
Both of these distances approximate a circle in 2D with a square or a sphere in 3D with a cube, the difference is that taxicab is an upper estimate of the distance while Chebyshev is the lower estimate. For speed of execution (optimization) it may also be important that taxicab distance only uses the operation of addition while Chebyshev may result in branching (if) in the max function which is usually not good for performance.
Taking the average of taxicab and Chebyshev distances will slightly increases accuracy towards better approximating Euclidean distance -- in 2D a circle plotted by this new metric will be an 8 segment polygon and analogously in 3D a sphere will be a 24 sided polyhedron (taxicab or Chebyshev alone give a square in 2D and a cube in 3D). The average can be shown to be equal to the maximum coordinate difference plus a half of the minimum; here is an branchless, integer-only C function implementing the taxicab-Chebyshev average:
int dist8(int x0, int y0, int x1, int y1)
{
x0 = x1 > x0 ? x1 - x0 : x0 - x1; // dx
y0 = y1 > y0 ? y1 - y0 : y0 - y1; // dy
x1 = x0 > y0; // use as helper
return (x0 >> !x1) + (y0 >> x1);
}
And a picture for summary:
--------------------------------------------------------------------------------
0 1 2 3 4 5 6
Euclidean _____ 1 1 2 3 4 5 6
_.'' ''._ 2 2 3 4 4 5 6
sqrt( B / \ 3 3 4 4 5 6 7
(B.x - A.x)^2 + _,-+ / C d \ 4 4 4 5 6 6 7 F
(B.y - A.y)^2) _,--' ( +-------) 5 5 5 6 6 7 8 _-+
_,--' \ / 6 6 6 7 7 8 8 _,-'
_,--' \_ _/ _,-'
A _,--' '--_____--' _,-'
+-' E _,-'
+-'
--------------------------------------------------------------------------------
0 1 2 3 4 5 6
Taxicab (Manhattan) _A_ 1 2 3 4 5 6 7
B _/ \_ 2 3 4 5 6 7 8
+ _/ \_ 3 4 5 6 7 8 9 F
abs(B.x - A.x) + | _/ C d \_ 4 5 6 7 8 9 a ,----+
abx(B.y - A.y) | <_ +-------> 5 6 7 8 9 a b ,'
| \_ _/ 6 7 8 9 a b c ,'
| \_ _/ ,'
A | \_ _/ ,'
+-------------------------' V E ,'
+----'
--------------------------------------------------------------------------------
0 1 2 3 4 5 6
Chebyshev _______________ 1 1 2 3 4 5 6
B | | 2 2 2 3 4 5 6
max( + | | 3 3 3 3 4 5 6 F
abs(B.x - A.x), | C d | 4 4 4 4 4 5 6 ,+
abs(B.y - A.y)) | +-------| 5 5 5 5 5 5 6 ,'
| | 6 6 6 6 6 6 6 ,'
| | ,--------'
A |_______________| ,'
+-------------------------- E ,'
+'
--------------------------------------------------------------------------------
0 1 2 3 4 5 6
Taxi-Chebyshev average ___ 1 1 2 3 4 5 6
B _.-'' ''-._ 2 2 3 4 5 6 7
max(abs(B.x - A.x), + : : 3 3 4 4 5 6 7 F
abs(B.y - A.y)) + : C d : 4 4 5 5 6 7 8 __,+
min(abs(B.x - A.x), : +-------: 5 5 6 6 7 7 8 ,..''
abs(B.y - A.y)) / 2 . : : 6 6 7 7 8 8 9 /
| :_ _: /
A | ''-.___.-'' /
+-------------------------' __..'''
+''
--------------------------------------------------------------------------------
The four mentioned distance measures: the distance is the length of the path illustrated between points A and B; next are shown "circles" (sets of points with distance d from point C), tables of distances of grid cells from the top-left cell (rounded to nearest integer if needed) and "lines" (one diagonal of a rhombus in which points E and F are opposite to each other) drawn by respective measures.
{ The following is an approximation I came up with when working on tinyphysicsengine. While I measured the average and maximum error of the taxi/Chebyshev average in 3D at about 16% and 22% respectively, the following gave me 3% and 12% values. ~drummyfish }
Yet a more accurate approximation of 3D Euclidean distance can be achieved with a 48 sided polyhedron. The principle is following: take absolute values of all three coordinate differences and order them by magnitude so that dx >= dy >= dz >= 0. This gets us into one of 48 possible slices of space (the other slices have the same shape, they just differ by ordering or signs of the coordinates but the distance in them is of course equal). In this slice we'll approximate the distance linearly, i.e. with a plane. We do this by simply computing the distance of our point from a plane that goes through origin and whose normal is approximately {0.8728,0.4364,0.2182} (it points in the direction that goes through the middle of space slice). The expression for the distance from this plane simplifies to simply 0.8728 * dx + 0.4364 * dy + 0.2182 * dz. The following is an integer-only implementation in C (note that the constants above have been converted to allow division by 1024 for possible optimization of division to a bit shift):
int32_t dist48(
int32_t x0, int32_t y0, int32_t z0,
int32_t x1, int32_t y1, int32_t z1)
{
x0 = x1 > x0 ? x1 - x0 : x0 - x1; // dx
y0 = y1 > y0 ? y1 - y0 : y0 - y1; // dy
z0 = z1 > z0 ? z1 - z0 : z0 - z1; // dz
if (x0 < y0) // order the coordinates
{
if (x0 < z0)
{
if (y0 < z0)
{ // x0 < y0 < z0
int32_t t = x0; x0 = z0; z0 = t;
}
else
{ // x0 < z0 < y0
int32_t t = x0; x0 = y0; y0 = t;
t = z0; z0 = y0; y0 = t;
}
}
else
{ // z0 < x0 < y0
int32_t t = x0; x0 = y0; y0 = t;
}
}
else
{
if (y0 < z0)
{
if (x0 < z0)
{ // y0 < x0 < z0
int32_t t = y0; y0 = z0; z0 = t;
t = x0; x0 = y0; y0 = t;
}
else
{ // y0 < z0 < x0
int32_t t = y0; y0 = z0; z0 = t;
}
}
}
return (893 * x0 + 446 * y0 + 223 * z0) / 1024;
}
A similar approximation for 2D distance is (from a 1984 book Problem corner) this: sqrt(dx^2 + dy^2) ~= 0.96 * dx + 0.4 * dy for dx >= dy >= 0. The error is <= 4%. This can be optionally modified to use the closest power of 2 constants so that the function becomes much faster to compute, but the maximum error increases (seems to be about 11%). C code with fixed point follows (commented out line is the faster, less accurate version):
int dist2DApprox(int x0, int y0, int x1, int y1)
{
x0 = x0 > x1 ? (x0 - x1) : (x1 - x0);
y0 = y0 > y1 ? (y0 - y1) : (y1 - y0);
if (x0 < y0)
{
x1 = x0; // swap
x0 = y0;
y0 = x1;
}
return (123 * x0 + 51 * y0) / 128; // max error = ~4%
//return x0 + y0 / 2; // faster, less accurate
}
TODO: this https://www.flipcode.com/archives/Fast_Approximate_Distance_Functions.shtml
Doom is a legendary video game released in December 1993, perhaps the most famous video game of all time, the game that popularized the first man shooter genre and shocked by its at the time extremely advanced 3D graphics (yes, Doom is 3D) and caused one of the biggest revolutions in video game history. It was made by Id Software, most notably by John Carmack (graphics + engine programmer) and John Romero (tool programmer + level designer) -- all in all the game was developed by about 5 to 6 men in about a year. Doom is sadly proprietary, it was originally distributed as shareware (a gratis "demo" was available for playing and sharing with the option to buy a full version). However the game engine was later (1999) released as free (as in freedom) software under GPL which gave rise to many source ports and "improved" "modern" engines (which however look like shit, the original looks by far the best, if you want to play Doom use Chocolate Doom or Crispy Doom, avoid anything with GPU rendering). The assets remain non-free but a completely free alternative is offered by the Freedoom project that has created free as in freedom asset replacements for the game. Anarch is an official LRS game inspired by Doom, completely in the public domain.
{ NOTE: Some followers expressed disgust about the fact that I "glorify" Doom, a proprietary game -- yes, Doom is proprietary and thus an unethical piece of shit. Ethical "fixes" exist, namely Freedoom. Here I merely describe the historical significance of "Doom as a concept", it's the same as with "Unix" as a concept -- Unix was also proprietary, but its invention was very significant historically, it was a discovery of a certain kind of formula, almost like discovering a law of nature in science. Even if this is initially seized and held by capitalists, later on free clones usually manage to at least partially free the concept from proprietary hands. Just so we understand each other: I am fully AGAINST proprietary games, but things aren't black and white, a disaster may have historical significance and lead to something good, and vice versa. I am just capturing facts. ~drummyfish }
Doom has a cool wiki at https://doomwiki.org.
Only pussies play Doom on low difficulty. { Sorry Ramon, love u <3 :D ~drummyfish }
{ Great books about Doom I can recommend: Masters of Doom (about the development) and Game Engine Black Book: Doom (details about the engine internals). Also recently John Romero, who has a rare condition of being able to perfectly recall every day of his life, has written a book about the development, called Doom Guy. ~drummyfish }
In part owing to the release of the engine under a FOSS license and its relatively suckless design (C language, software rendering, ...), Doom has been ported, both officially and unofficially, to a great number of platforms (e.g. Gameboy Advance, PS1, even SNES) and has become a kind of de facto standard benchmark for computer platforms -- you will often hear the phrase: "but does it run Doom?" Porting a Doom to any platform has become kind of a meme, purportedly someone even ported it to a pregnancy test (though it didn't actually run on the test, it was really just a display). { Still Anarch may be even more portable than Doom :) ~drummyfish }
The major leap that Doom engine's graphics brought about was unprecedented, but Doom was not just a game with good graphics, it had fantastic gameplay, brutally good music and a fitting, badass art style, all polished and coherent in a very beautifully gory harmony, and on top of that there was the novel and revolutionary deathmatch multiplayer (the name deathmatch itself was coined by Romero during Doom multiplayer sessions), as well as a HUGE modding and mapping scene. Doom was a success in every way -- arguably no other game has since caused a revolution of greater proportions (no, not even Minecraft, World of Warcraft and whatever else). Many game magazines just started reviews with: "OK, Doom is clearly the best game ever made, let's just examine the details...". The game's overall style and atmosphere were just "cool", as were the developers themselves, Doom was very appealing by its sincere message that read "fuck it, we don't give a shit, let's make a great game". It was a pure metal/bloody/gory/demon slaying shooter without any corporate garbage stuffed in for more popularity and profit that you'd see today. It was a game made by a bunch of guys doing it their own way without giving much shit about family friendliness or marketing bullshit, you won't see that anymore. Doom didn't pretend, it didn't care about backstory, everyone knew it was about shooting and so they just made it a bloody shooter. John Carmack famously stated that story in a video game is like story in a porn movie -- it's expected to be there but not very important. Nowadays you may at best see developers try to artificially imitate this attitude but it's always laughably transparent, it will only ever be a pretense as the times when you could simply make a game with artistic freedom, without having to bow to managers, gender departments, publishers and other overlords are simply long gone by.
Doom wasn't the first 3D game, nor was it the first FPS, some of its predecessors could even be considered "more 3D" in a sense -- for example flight simulators -- what was so special and breathtaking about Doom was the mastery with which it combined all the graphic tricks in a novel way and still managed to complement them with excellent gameplay to deliver unprecedented "immersion", such that mere mortals of the 1990s couldn't expect and weren't ready for. Doom had fully textured environments, including floors and ceilings, which along with the fog, sector lighting, level verticality and interactivity made the player really feel present in the game despite not being able to look up and down. Games had textured walls before, and others had textured floors, some had lighting effects and distance fog, but Doom was the first to have it all and have it done the right way.
As stated, the game's backstory was simple and didn't stand in the way of gameplay, it's basically about a tough marine (so called Doomguy) on a Mars military base slaying hordes of demons from hell, all in a rock/metal style with a lot of gore and over-the-top violence (chain saws n stuff).
Doom was followed by Doom II in 1995, which "content-wise" was basically just a data disc, the same game with new levels and some minor additions. More Doom games followed, notably Final Doom and Doom 64, but these are a bit less known now. After the turn of the new millennium Doom III came out in 2004, which was a kind of "reboot" rather than a sequel. The game also got an expansion pack. Doom IV was in development but got canceled, so the next official game was Doom 2016 -- another reboot. In 2020 Doom: Eternal was released. And it still continues, but it's crap now.
Some interesting trivia about Doom include:
GOOBERS cheat code which makes all floors and ceilings the same height, effectively making the game a flat wolf3d-style game.
See also game engine for the list of different Doom engines. Tl;dr: to play doom nowadays use either Chocolate Doom or Crispy Doom.
Doom source code is written in C89 and is about 36000 lines of code long, spread over some 124 files, of which some were auto-generated (e.g. the AI state machines). The original system requirements stated roughly a 30 MHz CPU and 4 MB RAM as a minimum. It had 27 levels (9 of which were shareware), 8 weapons and 10 enemy types. The engine wasn't really as flexible in a way "modern" programmers expect, many things were hard coded, there was no scripting or whatever (see? you don't fucking need it), new games using the engine had to usually modify the engine internals. Compared to its predecessor (Wolf 3D), successor (Quake) and competition (Duke 3D), Doom's code is arguably the nicest and closest to LRS.
The code itself looks alright, files are conveniently organized into groups by their prefix (g_: game, r_: rendering, s_: sound etc.). The same goes for the function names. There seems to be tabs mixed with spaces though, sometimes a bit shitty formatting, but overall MUCH better than duke 3D's code (well, that doesn't say much though). Comments are plentiful.
The game only used fixed point, no float!
The Doom engine (also called id Tech 1) was revolutionary and advanced (not only but especially) video game graphics by a great leap, considering its predecessor Wolf3D was really primitive in comparison (Doom basically set the direction for future trends in games such as driving the development of more and more powerful GPUs in a race for more and more impressive visuals). In early stages the game used a portal renderer but it turned out running too slow with more complex scenes, so John Carmack switched to a new technique called BSP rendering (levels were made of convex 2D sectors that were then placed in a BSP tree which helped quickly sort the walls for rendering front-to-back) that was able to render realtime 3D views of textured (all walls, floors and ceilings) environments with primitive lighting (per-sector plus diminishing lighting), enemies and items represented by 2D billboards ("sprites"). The BSP rending was especially elegant in that it always drew each screen pixel exactly once, without overdraw or "holes" left behind, and thanks to this it wasn't even necessary to clear the video buffer inbetween frames. No GPU acceleration was used, graphics was rendered purely with CPU (so called software rendering, GPU rendering would come with Doom's successor Quake, and would also later be brought to Doom by newer community made engines, though the original always looks the best). This had its limitations, for example the camera could not look up and down, there could be no tilted walls and the levels could not have rooms above other rooms. The geometry of levels was only static, i.e. it could not change during play (only height of walls could, which is why walls always opened upwards), because rendering was dependent on precomputed BSP trees (which is what made it so fast). For these reasons some call Doom "pseudo 3D" or 2.5D rather than "true 3D", some retards took this even as far as calling Doom 2D with its graphics being just an "illusion", as if literally every 3D graphics ever wasn't a mere illusion. Nevertheless, though with limitations, Doom did present 3D views and internally it did work with 3D coordinates (for example the player or projectiles have 2D position plus height coordinate), despite some dumb YouTube videos saying otherwise. For this reason we prefer to call Doom a primitive 3D engine, but 3D nonetheless. Other games later used the Doom engine, such as Heretic, Hexen and Strife. The Doom engine was similar to and competing with Build engine that ran games like Duke Nukem 3D, Blood and Shadow Warrior. All of these 90s shooters were amazing in their visuals and looked far better than any modern shit. Build engine games had similar limitations to those of the Doom engine but would improve on them (e.g. faking looking up and down by camera tilting, which could in theory be done in Doom too, or allowing sloped floor and dynamic level geometry).
Indexed (palette) mode with "only" 256 colors was used for rendering. Precomputed color tables were used to make dimming of colors faster. Similarly a look up table was used for random number generation -- two independent pseudorandom generators are present, one is used for things such as visual effects while the other one is utilized purely for the game simulation so that it stays deterministic independently on graphics etc.
The game data is stored in so called WAD files (short for where's all the data). While many things are hardcoded in the engine, such as the total number of levels or types of weapons, most other things such as textures, levels, color palettes, weapons and enemy sprites are in the WAD files and so can be replaced without having to mess with the engine itself. There are two types of WAD files (both however still come with the same .wad extension, they are distinguished only by the file magic number): IWAD (internal WAD) and PWAD (patch WAD). IWAD is the most important one, representing the base game, so for example Doom, Hexen and Freedoom will all have their own specific IWAD. Only one IWAD is loaded at any time. PWAD allows to add or modify things in the IWAD which makes it possible to easily correct bugs in the game data and make mods. Unlike with IWADs, multiple PWADs can be loaded at any time -- when loaded, a resource that's present in the PWAD will override the same resource in the base IWAD. All resources in the WAD files are stored as so called lumps which we may simply see as "blobs of data" or "files". A nice CLI tool for working with WADs is e.g. deutex.
Doom WAD (full version) is a bit over 11 MB in size (MD5 1cd63c5ddff1bf8ce844237f580e9cf3), Doom 2 WAD is over 14 MB (MD5 25e1459ca71d321525f84628f45ca8cd).
The engine uses a custom memory allocator, i.e. standard library malloc is not relied on, which is good too. The reason for this is again the need for total control and being able to tailor a custom memory allocation system ensuring good performance. Upon starting the game it immediately allocates a big chunk of RAM (4 MiB, or 8 if available) and here the custom function (Z_Malloc) does its thing.
Doom also has a deterministic, FPS-independent physics which allows for efficient recording of demos of its gameplay and creating tool assisted speedruns, i.e. the time step of game simulation is fixed (35 tics per second). Such demos can be played back in high quality while being minuscule in size and help us in many other ways, for example for verifying validity of speedruns. This is very nice and serves as an example of a well written engine (unlike later engines from the same creators, e.g. those of Quake games which lacked this feature -- here we can see how things get progressively shittier in computer technology as we go forward in time).
There is no antialiasing in the engine, i.e. aliasing can be noticed on far-away textures, but it is suppressed by the use of low-res textures and dimming far-away areas. There is also no edge smoothing (kind of misleadingly known as "antialiasing") in the geometry rendering, the engine is subpixel accurate in rendering of the top and bottoms of the walls, i.e. the line these boundaries form may result in rasterizing slightly different pixels even if the start and end pixel is the same, depending on the subpixel position of the start and endpoint -- this feature doesn't much help in static screenshots but makes animation nicer.
Some interesting places in code: m_random.c:31: pseudorandom number table; i_main.c: the C main function (for DOS); d_main.c:354: game loop; r_main.c:870: 3D rendering function. am_map.c:992: variable named fuck (the code contains total of 20 lines containing "fuck").
In computer graphics double buffering is a technique of rendering in which we do not draw directly to video RAM, but instead to a second "back buffer", and only copy the rendered frame from back buffer to the video RAM ("front buffer") once the rendering has been completed; this prevents flickering and displaying of incompletely rendered frames on the display. Double buffering requires a significant amount of extra memory for the back buffer, however it is also necessary for how graphics is rendered today.
here we are this is seen
drawing on display
| |
V V
.--------. when drawing is done .--------.
| | we copy this | |
| back | -----------------------> | front |
| buffer | | buffer |
|________| |________|
In most libraries and frameworks today you don't have to care about double buffering, it's done automatically. For this reason in many frameworks you often need to indicate the end of rendering with some special command such as flip, endFrame etc. If you're going lower level, you may need to implement double buffering yourself.
Though we encounter the term mostly in computer graphics, the principle of using a second buffer in order to ensure the result is presented only when it's ready can be applied also elsewhere.
Let's take a small example: say we're rendering a frame in a 3D game. First we render the environment, then on top of it we render the enemies, then effects such as explosions and then at the top of all this we render the GUI. Without double buffering we'd simply be rendering all these pixel into the front buffer, i.e. the memory that is immediately shown on the display. This would lead to the user literally seeing how first the environment appears, then enemies are drawn over it, then effects and then the GUI. Even if all this redrawing takes an extremely short time, it is also the case that the final frame will be shown for a very short time before another one will start appearing, so in the result the user will see huge flickering: the environment may look kind of normal but the enemies, effects and GUI may appear transparent because they are only visible for a fraction of the frame. The user also might be able to see e.g. enemies that are supposed to be hidden behind some object if that object is rendered after the enemies. With double buffering this won't happen as we perform the rendering into the back buffer, a memory which doesn't show on the display. Only when we have completed the frame in the back buffer, we copy it to the front buffer, pixel by pixel. Here the user may see the display changing from the old frame to the new one from top to the bottom, but he will never see anything temporary, and since the old and new frames are usually very similar, this top-to-bottom update may not even be distracting (it is addressed by vertical synchronization if we really want to get rid of it).
There also exists triple buffering which uses yet another additional buffer to increase FPS. With double buffering we can't start rendering a new frame into back buffer until the back buffer has been copied to the front buffer which may further be delayed by vertical synchronization, i.e. we have to wait and waste some time. With triple buffering we can start rendering into the other back buffer while the other one is being copied to the front buffer. Of course this consumes significantly more memory. Also note that triple buffering can only be considered if the hardware supports parallel rendering and copying of data, and if the FPS is actually limited by this... mostly you'll find your FPS bottleneck is elsewhere in which case it makes no sense to try to implement triple buffering. On small devices like embedded you probably shouldn't even think about this.
Double buffering can be made more efficient by so called page flipping, i.e. allowing to switch the back and front buffer without having to physically copy the data, i.e. by simply changing the pointer of a display buffer. This has to be somehow supported by hardware.
When do we actually need double buffering? Not always, we can avoid it or suppress its memory requirements if we need to, e.g. with so called frameless rendering -- we may want to do this e.g. in embedded programming where we want to save every byte of RAM. The mainstream computers nowadays simply always run on a very fast FPS and keep redrawing the screen even if the image doesn't change, but if you write a program that only occasionally changes what's on the screen (e.g. an e-book reader), you may simply leave out double buffering and actually render to the front buffer once the screen needs to change, the user probably won't notice any flicker during a single quick frame redraw. You also don't need double buffering if you're able to compute the final pixel color right away, for example with ray tracing you don't need any double buffering, unless of course you're doing some complex postprocessing. Double buffering is only needed if we compute a pixel color but that color may still change before the frame is finished. You may also only use a partial double buffer if that is possible (which may not be always): you can e.g. split the screen into 16 regions and render region by region, using only a 1/16th size double buffer. Using a palette can also make the back buffer smaller: if we use e.g. a 256 color palette, we only need 1 byte for every pixel of the back buffer instead of some 3 bytes for full RGB. The same goes for using a smaller resolution that is the actual native resolution of the screen.
Duke Nukem 3D (often just duke 3D) is a legendary first man shooter video game released in January 1996 (as shareware), one of the best known such games and possibly the second greatest 90s FPS right after Doom. It was made by 3D realms, a company competing with Id software (creators of Doom), in engine made by Ken Silverman -- the game was developed by around 10 people and was in the making since 1994. Duke 3D is a big sequel to two previous games which were just 2D platformers (and a prequel to the infamously unsuccessful Duke Nukem Forever); when this 3rd installment came out, it became a hit. It is remembered not only for being very technologically advanced, further pushing advanced fully textured 3D graphics that Doom introduced, but also for its great gameplay, iconic music and above all for its humor and excellent parody of the prototypical 80s overtestosteroned alpha male hero, the protagonist Duke himself -- it showed a serious game didn't have to take itself too seriously and became loved exactly for things like weird alien enemies or correct portrayal of women as mere sexual objects which nowadays makes feminists screech in furious rage of thousand suns. Only idiots criticised it. Duke was later ported to other platforms (there was even a quite impressive 3D port for GBA) and received a lot of additional "content".
Of course, Duke is sadly proprietary, as most gaymes, though the source code was later released as FOSS under GPL (excluding the game data and proprietary engine, which is only source available). A self-proclaimed FOSS engine for Duke with GPU accelerated graphics exists: EDuke32 -- the repository is kind of a mess though and it's hard to tell if it is legally legit as there are parts of the engine's proprietary code (which may be actually excluded from the compiled binary), so... not sure.
Duke was very much influenced by a very cool anticapitalist movie called They Live, up to the point of completely copy pasting some of the most memorable lines.
The codebase (including Build engine) is roughly 100000 LOC of C, with some parts in assembly. Programming style looks like a disaster, formatting of the code isn't nicest (at least in the version reviewed here, got somewhere from the net), tabs are mixed with spaces, there are large parts of code commented out, inserting spaces and newlines is inconsistent, looks like a work in progress temporary code. There is A GREAT DEAL of magic constants and spaghetti code (for example just randomly found: if inside while inside if inside if inside if inside else if inside switch inside while -- doing it may be OK sometimes, but here it's all over the place constantly). Yes, there are even gotos. { I think John Carmack also said the code looked like complete garbage. ~drummyfish }
The original system requirements were roughly following: 66 MHz CPU, 16 MB RAM and 30 MB storage space.
Duke ran on Build engine, a legendary software rendering primitive 3D engine that had limitations similar to those of Doom engine, i.e. the camera could not genuinely rotate up or down (though it could fake this with kind of a "tilting") and things like rooms above other rooms in a level were allowed only in limited ways (hacks such as extra rendering passes or invisible teleports were used to allow this). The engine was not unsimilar to that of Doom, enemies and other objects were represented with 2D sprites and levels were based on the concept of sectors (a level was really made as a 2D map in which walls were assigned different heights and textures), however it had new features -- most notably dynamic environment, meaning that levels could change on the fly without the need for precomputation, allowing e.g. destructible environments. How the fuck did they achieve this? Instead of BSP rendering (used by Doom) Build engine used portal rendering: basically (put in a quite simplified way) there was just a set of sectors, some of which shared walls ("portals") -- rendering would first draw the sector the player stood in (from the inside of course) and whenever it encountered a portal wall (i.e. a wall that sees into another sector), it would simply recursively render that too in the same way -- turns out this was just fine. Other extra features of the engine included tilted floors and ceilings, fake looking up/down, 3rd man view etc. The Build engine was also used in many other games (most notably Shadow Warrior and Blood) and later incorporated even more advanced stuff, such as voxel models, though these weren't yet present in Duke. Just like Doom, Build engine only used fixed point, no float! { Hmm, actually maybe there was a small exception, see the link below. ~drummyfish }
The game uses 256 colors and palettes.
Pseudorandom number generation is done with linear congruential generator (function krand), using multiplier 27584621 and adding 1, returning highest 16 bits of the result.
{ Here are some details on the engine internals from a guy who specializes on this stuff: https://fabiensanglard.net/duke3d/build_engine_internals.php. ~drummyfish }
Euler's number (not to be confused with Euler number), or e, is an extremely important and one of the most fundamental numbers in mathematics, approximately equal to 2.72, and is almost as famous as pi. It appears very often in mathematics and nature, it is the base of natural logarithm, its digits after the decimal point go on forever without showing a simple pattern (just as those of pi), and it has many more interesting properties.
It can be defined in several ways:
f(x) = e^x (so called exponential function) equals its own derivative, i.e. f(x) = f'(x).
1/0! + 1/1! + 1/2! + 1/3! + ... (! signifies factorial). I.e. adding all these infinitely many numbers gives exactly e.
1/x from 1 to e equals 1.
log(e,x) = area under the function's curve from 1 to x.
e to 100 decimal digits is:
`2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274...
e to 100 binary digits is:
`10.101101111110000101010001011000101000101011101101001010100110101010111111011100010101100010000000100...
Just as pi, e is a real transcendental number (it is not a root of any polynomial equation) which also means it is an irrational number (it cannot be expressed as a fraction of integers). It is also not known whether e is a normal number, which would means its digits would contain all possible finite strings, but it is conjectured to be so. As of 2023 e has been evaluated by computers to 35000000000000 digits.
A simple approximation of e is for example the fraction 1359/500.
Well, Earth is the planet we live on. It is the third planet from the Sun of our Solar system which itself is part of the Milky Way galaxy, Universe. So far it is the only known place to have life. Earth itself can also be seen as one huge organism.
Now behold the grand rendering of the Earth map in ASCII (equirectangular projection):
X v v v v v v v v v v v v v v v X
.-,./"">===-_.----..----.. : -==-
-=""-,><__-;;;<""._ / : -===-
___ .=---""""\/ \/ ><."-, "\ /" : .--._ ____ __.-""""------""""---.....-----..
> -=_ """""---"" _.-" \_/ | .-" /"\ : _.'' ".."" """ <
"" _.'ALASKA {_ ,".__ "" '"' _ : ( _/| _ _..
"-._.--"""-._ CANADA "--" "\ / \: ""./ / _--"","/
"" \ _/_ ",_/:_./\_.' ASIA "--. \/
> } /_\/ \:EUROPE __ __ /\| <
\ ""=- __.-" /"":_-. -._ _, /__\ \ ( .-" ) >-
\__ USA _/ """:___" " ", "" ,-. \ __//
|\ __ / /"": ""._..../ \ "" \_/
> \\_ ." \| ATLANTIC / : \\ <'\ | <
\ \_/| -=- OCEAN ) :AFRICA \\_.-" """\ .'
PACIFIC "--._\ \___: "/ \ .""\_ <^,..-" __
OCEAN \"""-""-.._ :""\ / " | _) \_\INDONESIA
>.............................|..........",.............:...\......./................_\\_....__/\..,__..........<
| SOUTH \ : / | "-._\_ \__/ \ ""-_
\ AMERICA / : ( } """""===- """""_
\_ | : \ \ __.-""._,"",
> \ / : / / |\ ," AUSTRALIA \ <
| | : \ / \/ INDIAN "; __ )
| / : \___/ OCEAN """ ""-._ /
/ / : "" |\
> | / : {) // <
| | : ""
\_ \ :
""" :
> ., : <
__....___ _/"" \ : _____ ___.......___......-------...__
--....-----""""----"""" "" "-..__ __......--""""""" """ .;_.....
"""" : ANTARCTICA
X ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ X
Some numbers about the planet Earth:
_---"""---_
.':. ;::.: -./;.
/;:;:: ': .-':::\
.|';:' ';':;:::|.
|:: .:'::;:::|
|::. ':;:::::|
'|:; ':;::|'
\:: .:::/
':_ .:_.'
"""----"""
Earth from space
Earth is the third planet from the Sun and the fifth largest in the Solar System, it has an ellipsoid shape, slightly flattened at the poles. It has formed from space dust nearly 5 billion years ago during the formation of our Solar System. Soon after its formation it was struck by a Mars-sized body, called Theia, which led to the formation of the Moon, Earth's only natural satellite. It's only by curious happenstance that the Moon is currently of the same size in the sky as the Sun, allowing perfect eclipses -- nonetheless the Moon is constantly drifting further away from us and will be visually shrinking. Earth has a hot core (inner one of temperature around 5200 degrees Celsius), an atmosphere (78% nitrogen, 20% oxygen; almost wholly contained below 50 km above sea) and a magnetic field, its surface is mostly (71%) covered by water. Temperatures on the surface stay between -100 C and 60 C, with global average of 15 C. The whole surface consists of 16 large tectonic plates, around 100 km thick. Evidence suggests that life appeared on Earth some 3 and a half billion years ago. Earth's axis of rotation is tilted around 24 degrees, which results in change of seasons as the planet revolves around the Sun. Scientists predict that the Earth will be devoured by the Sun that will expand its radius significantly some 7 and a half billion years from now.
Coordinates: to define an exact location p on Earth's surface it's most common to use the geographic coordinate system comprising of latitude and longitude which function like this: latitude is the angle (in range -90 to 90 degrees) of Earth's center point towards equator and p (positive in northern hemisphere, negative in southern hemisphere; alternatively marked as N or S), longitude (in range -180 to 180 degrees) is the angular distance (positive to the east, negative to the west; alternatively marked as E or W) of p from the prime meridian, by convention chosen to be the line from north pole to south pole through the British Royal Observatory in Greenwich, UK. For example Hitler Pond, Ohio, USA is located at [39.554081, -82.990932] or [39deg 33' 14.6916" N, 82deg 59' 27.3552" W], coordinates [90 0] and [-90 0] point to the north and south pole respectively etc. The system suffers from some issues, such as that the two coordinates aren't the same kind of thing (i.e. unlike parallels, meridians are part of great circles and all intersect in the two poles) or that the poles have infinitely many coordinates because on either pole longitude loses a meaning, but in general it's been working well for centuries (for alternative coordinate systems please see the article on sphere). How many decimal places to use? It's a little complicated but in general something like this: for precision around 1 meter use 5 fractional decimals (x.abcde), for 10 meter precision 4 decimals, for 100 meter precision 3 decimals and so on. Of course this paragraph wouldn't be complete without some funny/interesting coordinates -- giant with giant penis in the UK: [50.8136, -2.475], swastika houses: [40.737, 17.734], another swastika: [32.676, -117.158], penis shaped building: [41.842, -89.486], miniature world map on a lake: [56.5905, 9.6415], recursive island: [62.65138, -97.7876], recursive lake: [62.651, -97.787], dinosaur meteorite impact epicenter: [21.4, -89.51], Nazca lines: [-14.697, -75.14], heart pond: [41.304, -81.902], Dubai artificial islands: [25.0, 54.99], weird pattern for calibrating satellites: [40.45, 93.740], Area 51: [37.227, -115.838], TODO: more. Are there any alternative coordinate systems?. Yes, see sphere.
LOL IM slightly drunk a little bit
The Elo system (named after Arpad Elo, NOT an acronym) is a mathematical system for rating the relative strength of players in a certain competitive game, most notably and widely used in chess but also elsewhere (video games, table tennis, ...). { I have seen a cool video where someone computed the Elo of all NPC players in the Pokemon games. ~drummyfish } Based on number of wins, losses and draws against other Elo rated opponents, the system computes a number (rating) for each player that highly correlates with that player's current strength/skill; as games are played, ratings of players are constantly being updated to reflect changes in their strength. The numeric rating can then be used to predict the probability of a win, loss or draw of any two players in the system, as well as doing all kinds of other nice things such as tracking player's improvement over time, constructing ladders of current top players and matchmaking players of similar strength in online games. For example if player A has an Elo rating of 1700 and player B 1400, A is expected to win in a game with player B with the probability of 85%. The system is designed in a very clever way -- it uses the ability to estimate the outcome of a game between two players and then corrects the ratings of the players based on whether they do better or worse than expected. This way the ratings change and converge to stop near the value that reflects the player's true strength. Elo is a system designed in a smart way but still remains mathematically a pretty "keep it simple" one -- this means it has a few flaws and shortcomings (mentioned below), which keep being addressed by alternative rating systems such as Glicko (which further adds e.g. confidence intervals). However the simplicity of Elo has also shown to be a big advantage, it does a great job for a very small "price" and this quality to price ratio so far seems to be uncontested. Elo is good enough for most practical uses without requiring too complex mathematics, constant availability of large volumes of data or high computational power. For this it remains in wide use, notwithstanding some other systems' objectively higher accuracy of prediction: here it shows that the perfect is the enemy of the good and that higher precision usually comes with more complexity and only yields diminishing returns. Elo seems to be stand at the sweet spot of complexity and accuracy.
What we call a "game" here need not always be a typical game, Elo rating may be used for example in a video sharing platform to help the recommendation algorithm by letting videos compete for attention and then assigning them rating. When the site recommends the user two videos at once, they are effectively playing a game to win attention: whichever gets clicked wins the game, and this way we may find out which videos are the most popular AND also how popular each one is relative to others.
The Elo system was created specifically for chess (even though it can be applied to other games as well, it doesn't rely on any chess specific rules) and described by Arpad Elo in his 1978 book called The Rating of Chessplayers, Past and Present, by which time it was already in use by FIDE. It replaced older rating systems, most notably the Harkness system.
Elo rates only RELATIVE performance, not absolute, i.e. the rating number of a player says nothing in itself, it is only the DIFFERENCE in rating points between two players that matters, so in an extreme case two players rated 300 and 1000 in one rating pool may in another one be rated 10300 and 11000 (the difference of 700 is the only thing that stays the same, mean value can change freely). This may be influenced by initial conditions and things such as rating inflation (or deflation) -- if for example a chess website assigns some start rating to new users which tends to overestimate an average newcomer's abilities, newcomers will come to the site, play a few games which they will lose, then they ragequit but they've already fed their points to the good players, causing the average rating of a good player to grow over time (it's basically like an economy where the rating points are the currency, new overrated players have the same effect as printing money). This is one of several issues the Elo system has to deal with. Other issues include for example magic constants: the constant K (change rate) and the initial rating of new players have to somehow be set, and the system itself doesn't say what the ideal values are.
Yet another shortcoming is that ratings (including relative differences) depend on the order of games. I.e. when several games are played between N players and we update the ratings after each game, then the ratings of all the players (and their differences, i.e. predictions the system will make) at the end will depend on the order in which the games were played -- playing the games with exact same results but in different order will generally result in different ratings. This also holds for grouping: we may update ratings after each game or group several games together and count them as one match, outcome of which will be the average outcome of all the games -- and this may affect ratings too. So the rating partially depends on something that has nothing to do with the player's skill. This may not be such a huge problem in practice, tiny differences and fluctuations are usually ignored, but eventually this IS an undesirable property of the system. Some other systems address this by always computing every player's rating based on whole history of games he ever played, which fixes the issue but also brings in more computational complexity (imagine having to recompute everything from scratch after every single game, AND having to keep the record of complete history of all games).
It also must be said that Elo is a simplification of reality, as is any attempt at capturing skill with a single number -- even though it is a very good predictor of something akin to a "skill" and outcomes of games, trying to capture "skill" with a single number is similar to trying to capture such a multidimensional attribute as intelligence with a single dimensional IQ number. For example due to psychology, many different areas of the game to be mastered and different playstyles transitivity may be broken in reality: it may happen that player A mostly beats player B, player B mostly beats player C and player C mostly beats player A, which Elo won't capture. However this is not an issue of the Elo system specifically but rather of our simplified model of reality -- any other system that tries to capture skill as a one dimensional number, no matter how advanced, will suffer the same flaw.
Besides mathematical inaccuracies Elo (as well as other systems in general) also comes with more potential practical problems such as creating focus on grinding (players strategically choosing weaker opponents to maximize their rating), players refusing to play in order to not lose points, removing fun from games by implementing super effective matchmaking that just maximizes number of draws etcetc. Despite all the described flaws however it must be held that Elo is pretty nice and very useful, it's usually just its wrong application (for example in the mentioned matchmaking) where it starts to create trouble.
Elo rating can also be converted to (or from) alternative measures such as material or time advantage, i.e. given let's say two chess players with known ratings, we may be able to say how big of a handicap the stronger player must suffer in order for the two to be on par. However the relationship will probably not be simple, we can't say "this much Elo difference equals this many pawns in handicap" -- having a two pawn material advantage in a beginner game hardly makes a difference but on the absolute top level losing two pawns is decisively also a lost game (despite this some approximations were given, e.g. Fisher and Kannan estimated that in computer chess 100 Elo was roughly equivalent to one pawn).
Initial rating of players is not specified by Elo, each rating organization applies its own method (e.g. assign an arbitrary value of let's say 1000 or letting the player play a few unrated games to estimate his skill).
Suppose we have two players, player 1 with rating A and player 2 with rating B. In a game between them player 1 can either win, i.e. score 1 point, lose, i.e. score 0 points, or draw, i.e. score 0.5 points. (Some games may allow to give more possible outcomes besides win/loss/draw, some wins may be "stronger" than others for example -- this is still compatible with Elo as long as we can map the outcome to the range between 0 and 1.)
The expected score E of a game between the two players is computed using a sigmoid function (400 is just a magic constant that's usually used, it makes it so that a positive difference of 400 points makes a player 10 times more likely to win):
`E = 1 / (1 + 10^((B - A)/400))
For example if we set the ratings A = 1700 and B = 1400, we get a result E ~= 0.85, i.e in a series of many games player 1 will get an average of about 0.85 points per game, which can mean that out of 100 games he wins 85 times and loses 16 times (but it can also mean that out of 100 games he e.g. wins 70 times and draws 30). Computing the same formula from the player 2 perspective gives E ~= 0.15 which makes sense as the number of points expected to gain by the players have to add up to 1 (the formula says in what ratio the two players split the 1 point of the game).
After playing a game the ratings of the two players are adjusted depending on the actual outcome of the game. The winning player takes some amount of rating points from the loser (i.e. the loser loses the same amount of point the winner gains which means the total number of points in the system doesn't change as a result of games being played). The new rating of player 1, A2, is computed as:
`A2 = A + K * (R - E)
where R is the outcome of the game (for player 1, i.e. 1 for a win, 0 for loss, 0.5 for a draw) and K is the change rate which affects how quickly the ratings will change (can be set to e.g. 30 but may be different e.g. for new or low rated players). So with e.g. K = 25 if for our two players the game ends up being a draw, player 2 takes 9 points from player 1 (A2 = 1691, B2 = 1409, note that drawing a weaker player is below the expected result).
How to compute Elo difference from a number of games? This is useful e.g. if we have a chess engine X with Elo EX and a new engine Y whose Elo we don't know: we may let these two engines play 1000 games, note the average result E and then compute the Elo difference of the new engine against the first engine from this formula (derived from the above formula by solving for Elo difference B - A):
`B - A = log10(1 / E - 1) * 400
Here is a C code that simulates players of different skills playing games and being rated with Elo. Keep in mind the example is simple, it uses the potentially imperfect rand function etc., but it shows the principle quite well. At the beginning each player is assigned an Elo of 1000 and a random skill which is normally distrubuted, a game between two players consists of each player drawing a random number in range from from 1 to his skill number, the player that draws a bigger number wins (i.e. a player with higher skill is more likely to win).
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define PLAYERS 101
#define GAMES 10000
#define K 25 // Elo K factor
typedef struct
{
unsigned int skill;
unsigned int elo;
} Player;
Player players[PLAYERS];
double eloExpectedScore(unsigned int elo1, unsigned int elo2)
{
return 1.0 / (1.0 + pow(10.0,((((double) elo2) - ((double) elo1)) / 400.0)));
}
int eloPointGain(double expectedResult, double result)
{
return K * (result - expectedResult);
}
int main(void)
{
srand(100);
for (int i = 0; i < PLAYERS; ++i)
{
players[i].elo = 1000; // give everyone initial Elo of 1000
// normally distributed skill in range 0-99:
players[i].skill = 0;
for (int j = 0; j < 8; ++j)
players[i].skill += rand() % 100;
players[i].skill /= 8;
}
for (int i = 0; i < GAMES; ++i) // play games
{
unsigned int player1 = rand() % PLAYERS,
player2 = rand() % PLAYERS;
// let players draw numbers, bigger number wins
unsigned int number1 = rand() % (players[player1].skill + 1),
number2 = rand() % (players[player2].skill + 1);
double gameResult = 0.5;
if (number1 > number2)
gameResult = 1.0;
else if (number2 > number1)
gameResult = 0.0;
int pointGain = eloPointGain(eloExpectedScore(
players[player1].elo,
players[player2].elo),gameResult);
players[player1].elo += pointGain;
players[player2].elo -= pointGain;
}
for (int i = PLAYERS - 2; i >= 0; --i) // bubble-sort by Elo
for (int j = 0; j <= i; ++j)
if (players[j].elo < players[j + 1].elo)
{
Player tmp = players[j];
players[j] = players[j + 1];
players[j + 1] = tmp;
}
for (int i = 0; i < PLAYERS; i += 5) // print
printf("#%d: Elo: %d (skill: %d\%)\n",i,players[i].elo,players[i].skill);
return 0;
}
The code may output e.g.:
#0: Elo: 1134 (skill: 62%) #5: Elo: 1117 (skill: 63%) #10: Elo: 1102 (skill: 59%) #15: Elo: 1082 (skill: 54%) #20: Elo: 1069 (skill: 58%) #25: Elo: 1054 (skill: 54%) #30: Elo: 1039 (skill: 52%) #35: Elo: 1026 (skill: 52%) #40: Elo: 1017 (skill: 56%) #45: Elo: 1016 (skill: 50%) #50: Elo: 1006 (skill: 40%) #55: Elo: 983 (skill: 50%) #60: Elo: 974 (skill: 42%) #65: Elo: 970 (skill: 41%) #70: Elo: 954 (skill: 44%) #75: Elo: 947 (skill: 47%) #80: Elo: 936 (skill: 40%) #85: Elo: 927 (skill: 48%) #90: Elo: 912 (skill: 52%) #95: Elo: 896 (skill: 35%) #100: Elo: 788 (skill: 22%)
We can see that Elo quite nicely correlates with the player's real skill.
Fixed point arithmetic is a simple and often good enough method of representing fractional numbers (i.e. numbers with higher precision than integers, e.g. 4.03) in computers, as opposed to a more complicated floating point (which in most cases we consider a worse, more bloated option). Probably in 99% cases when you think you need floating point, fixed point will do just fine (this is also advocated e.g. in the book Starting Forth). Fixed point arithmetic is not to be confused with fixed point of a function in mathematics (fixed point of a function f(x) is such x that f(x) = x), a completely unrelated term.
Fixed point has at least these advantages over floating point:
What are the disadvantages? Well, sometimes precision may be lacking for example, resulting in nuisances such as more "jerky" movement in 3D engines, although there are always tricks and ways to fix this (increasing precision, interpolation, smoothing filters, ...), but they may sometimes prove to be quite complex themselves. While older/simpler computers will benefit from fixed point, the big/"modern" computers on the other hand may as we'll typically be using our own software implementation which has to compete with hardware accelerated floating point (still, we argue to rather favor the older/simpler computers). Also fixed point won't offer all the comfort that floating point nowadays comes with such as dealing with overflows etc. This is of course not an inherent disadvantage of fixed point but rather the status quo of computing industry, it's because floating point has been pimped and is delivered on a silver platter. In general using fixed point is a bit more work: we have to correctly choose the precision, manually adjust order of arithmetic operations, check for/prevent overflows etc., but in the end we get a better program. We have to argue for doing things well rather than quickly.
Fixed point uses a fixed (hence the name) number of digits (bits in binary) for the integer part and the rest for the fractional part (whereas floating point's fractional part varies in size). I.e. we split the binary representation of the number into two parts (integer and fractional) by IMAGINING a radix point at some place in the binary representation. That's basically it. Fixed point therefore spaces numbers uniformly, as opposed to floating point whose spacing of numbers is non-uniform.
So, we can just use an integer data type as a fixed point data type, there is no need for libraries or special hardware support. We can also perform operations such as addition the same way as with integers. For example if we have a binary integer number represented as 00001001, 9 in decimal, we may say we'll be considering a radix point after let's say the sixth place, i.e. we get 000010.01 which we interpret as 2.25 (2^2 + 2^(-2)). The binary value we store in a variable is the same (as the radix point is only imagined), we only INTERPRET it differently.
We may look at it this way: we still use integers but we use them to count smaller fractions than 1. For example in a 3D game where our basic spatial unit is 1 meter our variables may rather contain the number of centimeters (however in practice we should use powers of two, so rather 1/128ths of a meter). In the example in previous paragraph we count 1/4ths (we say our scaling factor is 1/4), so actually the number represented as 00000100 is what in floating point we'd write as 1.0 (00000100 is 4 and 4 * 1/4 = 1), while 00000001 means 0.25.
This has just one consequence: we have to normalize results of multiplication and division (addition and subtraction work just as with integers, we can normally use the + and - operators). I.e. when multiplying, we have to divide the result by the inverse of the fractions we're counting, i.e. by 4 in our case (1/(1/4) = 4). Similarly when dividing, we need to MULTIPLY the result by this number. This is because we are using fractions as our units and when we multiply two numbers in those units, the units multiply as well, i.e. in our case multiplying two numbers that count 1/4ths give a result that counts 1/16ths, we need to divide this by 4 to get the number of 1/4ths back again (this works the same as e.g. units in physics, multiplying number of meters by number of meters gives meters squared). For example the following integer multiplication:
`00001000 * 00000010 = 00010000 (in decimal: 8 * 2 = 16)
in our system has to be normalized like this:
`(000010.00 * 000000.10) / 4 = 000001.00 (in decimal: 2.0 * 0.5 = 1.0)
SIDE NOTE: in practice you may see division replaced by the shift operator (instead of /4 you'll see >> 2).
With this normalization we also have to think about how to bracket expressions to prevent rounding errors and overflows, for example instead of (x / y) * 4 we may want to write (x * 4) / y; imagine e.g. x being 00000010 (0.5) and y being 00000100 (1.0), the former would result in 0 (incorrect, rounding error) while the latter correctly results in 0.5. The bracketing depends on what values you expect to be in the variables so it can't really be done automatically by a compiler or library (well, it might probably be somehow handled at runtime, but of course, that will be slower). There are also ways to prevent overflows e.g. with clever bit hacks.
The normalization and bracketing are basically the only things you have to think about, apart from this everything works as with integers. Remember that this all also works with negative number in two's complement, so you can use a signed integer type without any extra trouble.
Remember to always use a power of two scaling factor -- this is crucial for performance. I.e. you want to count 1/2th, 1/4th, 1/8ths etc., but NOT 1/10ths, as might be tempting. Why are power of two good here? Because computers work in binary and so the normalization operations with powers of two (division and multiplication by the scaling factor) can easily be optimized by the compiler to a mere bit shift, an operation much faster than multiplication or division.
For start let's compare basic arithmetic operations in C written with floating point and the same code written with fixed point. Consider the floating point code first:
float
a = 21,
b = 3.0 / 4.0,
c = -10.0 / 3.0;
a = a * b; // multiplication
a += c; // addition
a /= b; // division
a -= 10; // subtraction
a /= 3; // division
printf("%f\n",a);
Equivalent code with fixed point may look as follows:
#define UNIT 1024 // our "1.0" value
int
a = 21 * UNIT,
b = (3 * UNIT) / 4, // note the brackets, (3 / 4) * UNIT would give 0
c = (-10 * UNIT) / 3;
a = (a * b) / UNIT; // multiplication, we have to normalize
a += c; // addition, no normalization needed
a = (a * UNIT) / b; // division, normalization needed, note the brackets
a -= 10 * UNIT; // subtraction
a /= 3; // division by a number NOT in UNITs, no normalization needed
printf("%d.%d%d%d\n", // writing a nice printing function is left as an exercise :)
a / UNIT,
((a * 10) / UNIT) % 10,
((a * 100) / UNIT) % 10,
((a * 1000) / UNIT) % 10);
These examples output 2.185185 and 2.184, respectively.
Now consider another example: a simple C program using fixed point with 10 fractional bits, computing square roots of numbers from 0 to 10.
#include <stdio.h>
typedef int Fixed;
#define UNIT_FRACTIONS 1024 // 10 fractional bits, 2^10 = 1024
#define INT_TO_FIXED(x) ((x) * UNIT_FRACTIONS)
Fixed fixedSqrt(Fixed x)
{
// stupid brute force square root
int previousError = -1;
for (int test = 0; test <= x; ++test)
{
int error = x - (test * test) / UNIT_FRACTIONS;
if (error == 0)
return test;
else if (error < 0)
error *= -1;
if (previousError > 0 && error > previousError)
return test - 1;
previousError = error;
}
return 0;
}
void fixedPrint(Fixed x)
{
printf("%d.%03d",x / UNIT_FRACTIONS,
((x % UNIT_FRACTIONS) * 1000) / UNIT_FRACTIONS);
}
int main(void)
{
for (int i = 0; i <= 10; ++i)
{
printf("%d: ",i);
fixedPrint(fixedSqrt(INT_TO_FIXED(i)));
putchar('\n');
}
return 0;
}
The output is:
0: 0.000 1: 1.000 2: 1.414 3: 1.732 4: 2.000 5: 2.236 6: 2.449 7: 2.645 8: 2.828 9: 3.000 10: 3.162
FizzBuzz is a relatively simple programming problem that's famous/infamous by having a number of different approach solutions and is often used e.g. in interviews to test the skills of potential hires. It comes from a child game that teaches basic integer division in which kids are supposed to shout a specific word if a number is divisible by some other number -- what's of interest about the problem is not the solution itself (which is trivial) but rather how one should structure an algorithm that solves the problem. The problem is stated as follows:
Write a program that writes out numbers from 1 to 100 (including both); however if a number is divisible by 3, write "Fizz" instead of the number, if the number is divisible by 5, write "Buzz" instead of it and if it is divisible by both 3 and 5, write "FizzBuzz" instead of it.
The statement may of course differ slightly, for example in saying how the output should be formatted or by specifying goals such as "make the program as short as possible" or "make the program as fast as possible". For the sake of this article let's consider the following the correct output of the algorithm:
1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, 17, Fizz, 19, Buzz, Fizz, 22, 23, Fizz, Buzz, 26,Fizz, 28, 29, FizzBuzz, 31, 32, Fizz, 34, Buzz, Fizz, 37, 38, Fizz, Buzz, 41, Fizz, 43, 44, FizzBuzz, 46, 47, Fizz, 49, Buzz, Fizz, 52, 53, Fizz, Buzz, 56, Fizz, 58, 59, FizzBuzz, 61, 62, Fizz, 64, Buzz, Fizz, 67, 68, Fizz, Buzz, 71, Fizz, 73, 74, FizzBuzz, 76, 77, Fizz, 79, Buzz, Fizz, 82, 83, Fizz, Buzz, 86, Fizz, 88, 89, FizzBuzz, 91, 92, Fizz, 94, Buzz, Fizz, 97, 98, Fizz, Buzz
Why the fuss around FizzBuzz? Well, firstly it dodges an obvious single elegant solution that many similar problems usually have and it leads a beginner to a difficult situation that can reveal a lot about his experience and depth of his knowledge. The tricky part lies in having to check not only divisibility by 3 and 5, but also by BOTH at once, which when following basic programming instincts ("just if-then-else everything") leads to inefficiently checking the same divisibility twice and creating some extra ugly if branches and also things like reusing magic constants in multiple places, conflicting the "DRY" principle etc. It can also show if the guy knows things usually unknown to beginners such as that the modulo operation with non-power-of-two is usually expensive and we want to minimize its use. However it is greatly useful even when an experienced programmer faces it because it can serve a good, deeper discussion about things like optimization; while FizzBuzz itself has no use and optimizing algorithm that processes 100 numbers is completely pointless, the problem is similar to some problems in practice in which the approach to solution often becomes critical, considering scalability. In practice we may very well encounter FizzBuzze's big brother, a problem in which we'll need to check not 100 numbers but 100 million numbers per second and check not only divisibility by 3 and 5, but by let's say all prime numbers. Problems like this come up e.g. in cryptography all the time, so we really have to come to discussing time complexity classes, instruction sets and hardware acceleration, parallelism, possibly even quantum computing, different paradigms etc. So really FizzBuzz is like a kind of great conversation starter, a bag of topics, a good training example and so on.
TODO: some history etc.
Let's see how we can implement, improve and optimize FizzBuzz in C. Keep in mind the question of scalability, i.e. try to imagine how the changes we make to the algorithm would manifest if the problem grew, i.e. if for example we wanted to check divisibility by many more numbers than just 1 and 5 etc. We will only focus on optimizing the core of the algorithm, i.e. the divisibility checking, without caring about other things like optimizing printing the commas between numbers and whatnot. Also we'll be supposing all compiler optimization are turned off so that the excuse "compiler will optimize this" can't be used :)
For starters let us write a kind of vanilla, naive solution that everyone will likely come up with as his first attempt. A complete noob will fail to produce even this basic version, a slightly advanced programmer (we might say a "coder") may submit this as the final solution.
#include <stdio.h>
int main(void)
{
for (int i = 1; i <= 100; ++i)
{
if (i != 1)
printf(", ");
if (i % 3 == 0 && i % 5 == 0)
printf("FizzBuzz");
else if (i % 3 == 0) // checking divisibility by 3 again :/
printf("Fizz");
else if (i % 5 == 0) // checking divisibility by 5 again :/
printf("Buzz");
else
printf("%d",i);
}
putchar('\n');
return 0;
}
It works, however with a number of issues. Firstly we see that for every number we check we potentially test the divisibility by 3 and 5 twice, which is not good, considering division (and modulo) are one of the slowest instructions. We also reuse the magic constants 3 and 5 in different places, which would start to create a huge mess if we were dealing with many more divisors. There is also a lot of branching, in the main divisibility check we may jump up to three times for the checked number -- jump instruction are slow and we'd like to avoid them (again, consider we were checking e.g. divisibility by 1000 different numbers). A first, tiny optimization (that here will likely be performed automatically) to notice is that i % 3 == 0 && i % 5 == 0 can be changed to just i % 15 == 0.
When asked to optimize the algorithm a bit more one might come up with something like this:
#include <stdio.h>
int main(void)
{
for (int i = 1; i <= 100; ++i)
{
if (i != 1)
printf(", ");
int printNum = 1;
if (i % 3 == 0)
{
printf("Fizz");
printNum = 0;
}
if (i % 5 == 0)
{
printf("Buzz");
printNum = 0;
}
if (printNum)
printf("%d",i);
}
putchar('\n');
return 0;
}
Now we check the divisibility by 3 and 5 only once for each tested number, and also keep only one occurrence of each constant in a single place, that's good. But we still keep the slow branching.
A bit more experienced programmer may now come with something like this:
#include <stdio.h>
int main(void)
{
for (int i = 1; i <= 100; ++i)
{
if (i != 1)
printf(", ");
switch ((i % 3 == 0) + ((i % 5 == 0) << 1))
{
case 1: printf("Fizz"); break;
case 2: printf("Buzz"); break;
case 3: printf("FizzBuzz"); break;
default: printf("%d",i); break;
}
}
putchar('\n');
return 0;
}
This solution utilizes a switch structure to only perform single branching in the divisibility check, based on a 2 bit value that in its upper bit records divisibility by 5 and in the lower bit divisibility by 3. This gives us 4 possible values: 0 (divisible by none), 1 (divisible by 3), 2 (divisible by 5) and 3 (divisible by both). The switch structure by default creates a jump table that branches right into the correct label in O(1).
We can even go as far as avoiding any branching at all with so called branchless programming, even though in this specific case saving one branch is probably not worth the cost of making it happen. But for the sake of completeness we can do e.g. something as follows.
#include <stdio.h>
char str[] = "\0\0\0\0\0\0\0\0Fizz\0\0\0\0Buzz\0\0\0\0FizzBuzz";
char *comma = ", ";
int main(void)
{
for (int i = 1; i <= 100; ++i)
{
// look mom, no branches!
char *s = str;
printf(comma + 2 * (i == 1));
*s = '1'; // convert number to string
s += i >= 100;
*s = '0' + (i / 10) % 10;
s += (*s != '0') | (i >= 100);
*s = '0' + i % 10;
int offset = ((i % 3 == 0) + ((i % 5 == 0) << 1)) << 3;
printf(str + offset);
}
putchar('\n');
return 0;
}
The idea is to have a kind of look up table of all options we can print, then take the thing to actually print out by indexing the table with the 2 bit divisibility value we used in the above example. Our lookup table here is the global string str, we can see it rather as an array of zero terminated strings, each one starting at the multiple of 8 index (this alignment to power of two will make the indexing more efficient as we'll be able to compute the offset with a mere bit shift as opposed to multiplication). The first item in the table is initially empty (all zeros) and in each loop cycle will actually be overwritten with the ASCII representation of currently checked number, the second item is "Fizz", the third item is "Buzz" and last one is "FizzBuzz". In each loop cycle we compute the 2 bit divisibility value, which will be a number 0 to 3, bit shift it by 3 to the left (multiply it by 8) and use that as an offset, i.e. the place where the printing function will start printing (also note that printing will stop at encountering a zero value). The conversion of number to ASCII is also implemented without any branches (and could be actually a bit simpler as we know e.g. the number 100 won't ever be printed). However notice that we pay a great price for all this: the code is quite ugly and unreadable and also performance-wise we many times waste time on converting the number to ASCII even if it then won't be printed, i.e. something that a branch can actually prevent, and the conversion actually further uses modulo and division instructions which we are trying to avoid in the first place... so at this point we probably overengineered this.
Now here is another approach. There is a mathematical observation to make and exploit: the first number that's divisible by both 3 and 5 is 15, and that is when the divisibility pattern (the sequence of Fizz, Buzz, Fizzbuzz and number print) starts to repeat for another 15 steps, and it's easy to see this 15 step pattern repeats until infinity. So we can really hard-code this 15 step cycle and just keep repeating it, for example like this (without even using division!)):
#include <stdio.h>
#define F "Fizz"
#define B "Buzz"
#define FB "FizzBuzz"
#define N "%d"
static const char *pattern[15] = {N,N,F,N,B,F,N,N,F,B,N,F,N,N,FB};
int main(void)
{
int p = 0;
for (int i = 1; i <= 100; ++i)
{
if (i > 1)
printf(", ");
printf(pattern[p],i);
p = p < 14 ? p + 1 : 0;
}
return 0;
}
Next we'll have a little bit of fun: if the problem asks for the shortest code, even on detriment of readability and efficiency, we might try the code golfer approach:
#include <stdio.h>
int i;main(){for(;i++<100;printf(", "+2*(i<2))&printf("%d\0FizzBuzz\0Fizz"+!(i%3)*12+!(i%5)*7%16,i));}
It's probably not minimal but can be a good start.
And here is a completely different approach that's probably not so practical, at least not in most common situations, but may be worth discussing and could get you some style points in the discussion. It works on the principle of sieve of Eratosthenes, the advantage is it doesn't need ANY DIVISION at all, however it needs more memory (although we can fix this, see below). The idea is basically to first go from 0 to 100 by steps of 3 and mark all numbers we visit as divisible by 3, then do the same for 5, and then finally we go one by one and do the printing -- we know whether each number is divisible by the numbers we are interested in thank to the marks. Here is the base version:
#include <stdio.h>
#define NMAX 100
unsigned char divisibility[NMAX + 1];
int main(void)
{
for (int i = 0; i <= NMAX; i += 3) // mark all multiples of 3
divisibility[i] |= 0x01;
for (int i = 0; i <= NMAX; i += 5) // mark all multiples of 5
divisibility[i] |= 0x02;
for (int i = 1; i <= NMAX; ++i)
{
if (i > 1)
printf(", ");
if (divisibility[i])
printf("%s%s",
(divisibility[i] & 0x01) ? "Fizz" : "",
(divisibility[i] & 0x02) ? "Buzz" : "");
else
printf("%d",i);
}
return 0;
}
Now let's try to improve this -- we can in fact remove the requirement for the big array in which we mark number divisibility, we can just keep the next multiple of 3 and next multiple of 5 and simply increase them once we reach them. Here is what it could look like:
#include <stdio.h>
int main(void)
{
int next3Mult = 3, next5Mult = 5;
for (int i = 1; i <= 100; ++i)
{
int printNum = 1;
if (i > 1)
printf(", ");
if (i == next3Mult)
{
printf("Fizz");
next3Mult += 3;
printNum = 0;
}
if (i == next5Mult)
{
printf("Buzz");
next5Mult += 5;
printNum = 0;
}
if (printNum)
printf("%d",i);
}
return 0;
}
Informally speaking fractal is a shape that's geometrically "infinitely complex" while being described in a very simple way, such as with a short formula or a few lines of algorithm written in a programming language. Shapes found in nature, such as trees, mountains, waves or clouds, often exhibit fractal structure. Fractals show self-similarity, i.e. upon "zooming" into an ideal fractal we observe that it is composed, down to an arbitrarily small scale, of shapes resembling the shape of the whole fractal; e.g. the branches of a tree look like smaller versions of the whole tree etc.
Fractals are the beauty of mathematics, easily seen even by non-mathematicians, so they are probably good as a motivational example in math education.
As for the history of fractal theory: mathematical interest in them appears to date back to 17th century and Gottfied Leibniz's study, although humans have been "intuitively" aware of fractal patterns for as long as anyone will remember, fractals are encountered in oldest architecture etc. At the beginning of 20th century two of the most iconic fractals were described: the Koch snowflake and Sierpinski triangle. This was followed by Felix Hausdorff's definition of fractal dimension in 1918. The word "fractal" was coined in 1975 by Benoit Mandelbrot. Computer graphics enabled by the newest technology then led to popularization and increased focus on fractals.
Fractal geometry is a sort of geometry whose subject lies in examination of these intricate shapes -- it turns out that unlike "normal" shapes such as circles and cubes whose attributes (such as circumference, volume, ...) are normally quite straightforward, perfect fractals (i.e. the mathematically ideal ones whose structure is infinitely complex) exhibit greatly counterintuitive properties -- like anything involving infinity, ideal fractals can get very tricky. It is possible for instance that a 2D fractal can have finite area but infinite circumference -- this is because the border is infinitely complex and swirls more and more as we zoom in, increasing the length of the border more and more the closer we look. This was famously noticed when people tried to measure lengths of rivers or coastlines (which are sort of fractal shapes) -- the length they measured always depended on the length of the ruler they used; the shorter ruler you use, the greater length you measure because the meanders of the details increase it. For this reason it is impossible to exactly and objectively give an exact length of rivers, coastlines etc.
Fractal is formed by iteratively or recursively (repeatedly) applying its defining rule -- once we repeat the rule infinitely many times, we've got a perfect fractal. In the real world, of course, both in nature and in computing, the rule is just repeat many times as we can't repeat literally infinitely. The following is an example of how iteration of a rule creates a simple tree fractal; the rule being: from each branch grow two smaller branches.
V V V V
\ / \ / V \ / \ / V
| | _| | | |_ >_| | | |_<
'-.| |.-' '-.| |.-' '-.| |.-'
\ / \ / \ / \ /
\ / \ / \ / \ /
| | | |
| | | |
| | | |
iteration 0 iteration 1 iteration 2 iteration 3
Mathematically fractal is a shape whose Hausdorff dimension (the "scaling factor of the shape's mass") may be non-integer and is bigger than its topological dimension (the "normal" dimension suh as 0 for a point, 1 for a line, 2 for a plane etc.). For example the Sierpinski triangle has a topological dimension 1 but Hausdorff dimension approx. 1.585 because if we scale it down twice, it decreases its "weight" three times (it becomes one of the three parts it is composed of); Hausdorff dimension is then calculated as log(3)/log(2) ~= 1.585.
L-systems are one possible way of creating fractals. They describe rules in form of a formal grammar which is used to generate a string of symbols that are subsequently interpreted as drawing commands (e.g. with turtle graphics) that render the fractal. The above shown tree can be described by an L-system. Among similar famous fractals are the Koch snowflake and Sierpinski Triangle.
Space filling curves are another curious example -- such a curve is infinitely long and completely fills a whole two (or even higher) dimensional area without leaving any gaps or crossing itself!
This demonstrates the intuitive "desire" of fractals to sit "in between dimensions", something that's formally captured by the mentioned Hausdorff dimension -- a space filling curve itself is one dimensional (a point on it can be identified with a single real number) but it also forms a two dimensional plane (or even a volume etc.). This means that in two dimensions we can actually choose to not use two spatial coordinates, as is natural, but can use just one, with the help of the space filling curve.
/\
/\/\
/\ /\
/\/\/\/\
/\ /\
/\/\ /\/\
/\ /\ /\ /\
/\/\/\/\/\/\/\/\
Sierpinski Triangle
Fractals don't have to be deterministic, sometimes the rules may involve randomness which will lead to the shapes be not perfectly self-similar (e.g. in the above shown tree fractal we might modify the rule to: grow 2 or 3 new branches, with equal probability of each, from each branch).
Another way of describing fractals is by iterative mathematical formulas that work with points in space. One of the most famous fractals formed this way is the Mandelbrot set. It is the set of complex numbers c such that the series z_next = (z_previous)^2 + c, z0 = 0 does not diverge to infinity. Mendelbrot set can nicely be rendered by assigning each iteration's result a different color; this produces a nice colorful fractal. Julia sets are very similar and there is infinitely many of them (each Julia set is formed like the Mandelbrot set but c is fixed for the specific set and z0 is the tested point in the complex plain).
Fractals may of course exist in 3 and more dimensions as well so we can also have animated 3D fractals etc.
Computers are good for exploring and rendering fractals as they can repeat given rule millions of times in a very short time. Programming fractals is quite easy thanks to their simple rules, yet this can highly impress noobs.
However, as shown by Code Parade (https://yewtu.be/watch?v=Pv26QAOcb6Q), complex fractals could be rendered even before the computer era using just a projector and camera that feeds back the picture to the camera. This is pretty neat, though it seems no one actually did it back then.
A nice FOSS program to interactively zoom into 2D fractals is e.g. xaos.
3D fractals can be rendered with ray marching and so called distance estimation. This works similarly to classic ray tracing but the rays are traced iteratively: we step along the ray and at each step use an estimate of the current point to the surface of the fractal; once we are "close enough" (below some specified threshold), we declare a hit and proceed as in normal ray tracing (we can render shadows, apply materials etc.). The distance estimate is done by some clever math.
Mandelbulber is a free, advanced software for exploring and rendering 3D fractals using the mentioned method.
Marble Racer is a FOSS game in which the player races a glass ball through levels that are animated 3D fractals. It also uses the distance estimation method implemented as a GPU shader and runs in real-time.
Fractals are also immensely useful in procedural generation, they can help generate complex art much faster than human artists, and such art can only take a very small amount of storage.
There exist also compression techniques based on fractals, see fractal compression.
There also exist such things as fractal antennas and fractal transistors.
Here is C code that draws one of the super simple fractals: Sierpinski triangle:
#include <stdio.h>
char sierpinski(int x, int y, int w, int h)
{
if (x >= w/2 && y < h/2)
return ' ';
if (w <= 1 || h <= 1)
return 'H';
return sierpinski(x % (w/2),y % (h/2),w/2,h/2);
}
int main(void)
{
#define W 32
#define H 32
for (int y = 0; y < W; ++y)
{
for (int x = 0; x < H; ++x)
{
char c = sierpinski(x,y,W,H);
putchar(c); putchar(c);
}
putchar('\n');
}
return 0;
}
which outputs:
HH HHHH HH HH HHHHHHHH HH HH HHHH HHHH HH HH HH HH HHHHHHHHHHHHHHHH HH HH HHHH HHHH HH HH HH HH HHHHHHHH HHHHHHHH HH HH HH HH HHHH HHHH HHHH HHHH HH HH HH HH HH HH HH HH HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH HH HH HHHH HHHH HH HH HH HH HHHHHHHH HHHHHHHH HH HH HH HH HHHH HHHH HHHH HHHH HH HH HH HH HH HH HH HH HHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHH HH HH HH HH HHHH HHHH HHHH HHHH HH HH HH HH HH HH HH HH HHHHHHHH HHHHHHHH HHHHHHHH HHHHHHHH HH HH HH HH HH HH HH HH HHHH HHHH HHHH HHHH HHHH HHHH HHHH HHHH HH HH HH HH HH HH HH HH HH HH HH HH HH HH HH HH HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
Frameless rendering is a technique of rendering animation by continuously updating an image on the screen by updating single (pseudo)randomly selected pixels rather than by drawing a quick succession of whole discrete frames. This is an alternative to the mainstream, typically double buffered frame-based rendering traditionally used nowadays.
This approach is typically compatible with image order rendering methods, i.e. ones that can immediately and independently compute the final color of any pixel on the screen -- for example raytracing. It won't work with object order techniques such as the commonly used 3D rasterization.
The main advantage of frameless rendering lies of course in saving a large amount of memory normally reserved for double buffering, and usually also increased performance (fewer pixels are processed per second, overhead of processing frames is eliminated, ...). The animation may also seem more smooth and responsive -- reaction to input is seen faster. Another advantage, and possibly a disadvantage as well, is the kind of "motion blur" created as a side effect of not updating the whole screen at once. Changes appear gradually and are spread over the screen and through time: some pixels show the scene at a newer time than others, so the previous images kind of blend with the newer ones. This may add realism and also prevent temporal aliasing, but blur may sometimes be undesirable, and also the kind of blur we get is "pixelated" and noisy.
Selecting the pixels to update can be done in many ways, often using pseudorandom patterns (jittered sampling, Halton sequence, Poisson Disk sampling, ...), but regular ones may also be used. There have been papers that implemented adaptive frameless rendering detecting where it's best to update pixels to minimize noise.
Historically similar (though different) techniques were used on computers that didn't have enough memory for a double buffer or redrawing the whole screen each frame was too intensive on the CPU; programmers had to identify which pixels had to be redrawn and only update those. This resulted in techniques like adaptive tile refresh used in scrolling games such as Commander Keen.
Not to be confused with open $ource.
Free (as in freedom) software is a type of ethical software that's respecting its users' freedom and preventing their abuse, generally by availability of its source code AND by a license that allows anyone to use, study, modify and share the software without restricting conditions (such as having to pay or get explicit permission from the author). Free software is NOT equal to software whose source code is just available publicly or software that is offered for zero price, the basic legal rights to the software are the key attribute that has to be present. Free software stands opposed to proprietary software -- the kind of abusive, closed software that capitalism produces by default. Free software is not to be confused with freeware ("gratis", software available for free); although free software is always available for free thanks to its definition, zero price is not its goal. The goal is freedom.
Free software is also known as free as in freedom, free as in speech software or libre software. It is sometimes equated with open source, even though open source is fundamentally different (evil), or neutrally labeled FOSS or FLOSS (free/libre and open-source software); sadly free software (as a term and concept) has lost to open source in mainstream popularity. In contrast to free software, software that is merely gratis (freeware) is sometimes called free as in beer.
Examples of free software include the GNU operating system (also known as "Linux"), GIMP (image editor), Stockfish chess engine, or games such as Xonotic and Anarch. Free software is actually what runs the world, it is a standard among experts and it is possible to do computing with exclusively free software (though this may depend on how far you stretch the definition), even though most normal people don't even know the term free software exists because they only ever come in contact with abusive proprietary consumer software such as Windows and capitalist games. There also exists a lot of big and successful software, such as Firefox, Linux (the kernel) or Blender, that's often spoken of as free software which may however be only technically true or true only to a big (but not full) degree: for example even though Linux is 99% free, in its vanilla version it comes with proprietary binary blobs which breaks the rules of free software. Blender is technically free but it is also capitalist software which doesn't really care about freedom and may de-facto limit some freedoms required by free software, even if they are granted legally by Blender's license. Such software is better called "open source" or FOSS because it doesn't meet the high standards of free software. This issue of technically-but-not-really free software is addressed by some newer movements and philosophies such as suckless and our less retarded software who usually also aim for unbloating technology so as to make it more free in practice.
____________________
.------------------------>| public source code |<-----. defined
; .---------------->|____________________| ; always mainly _____
; ; .------^ ; has ALL by | FSF |
; ; "should"; _______________________ ; ,-->|_____|
; ; have; | unlimited | ; ;
;doesn't; "most"; | use+stud+modify+share | ; _______ ; _________ high focus on
;have ; _____ ; |_______________________| ; | libre | ; main_.>| freedom |<------------.
; ; | OSI | ; ^ allows ^. ; |_______| ; goal_.' |_________| ;
; has; |_____| ; ; by allows'. ; ^ ; is_.' ______________ ;
; ; ^ ; ; license by'. ; AKA ; ; _.' | free culture |generalizes ;
; ; ;defined ; ____;___ license '.;______;_;_.' __..--|______________|<--. _.-'
; ; ;by '--| open | | free |<--''generalizes ___;_.-''
; ; '-----------| source |<----------------->| software |<-------------------------| LRS |--.
___;____ ;__________ .--|________| legally very |__________|<-..__ generalizes |_____| ;
| closed | | source | ; ^ ; ^. similar to .^ ; ^._ ''--_ ; ; ; primary
| source | | available | ; ; ; neutral'. _________ .'neutral ; '. ;is ; ; ; focus
|________| |___________| ; ; ; synonm '| F(L)OSS |'synonym ;is ; ;subset ; ; ; on
; ; ; ; ; for |_________| for ;always ; ;of generalizes; ; _v_________
; is; ; ; ; ______________ ; ; ___;______ ; ; | happiness |
; subset; main ; ; '------>| free of cost |<---------' ; | suckless |<---------' ; | of all |
; of; goal is ; ; is |______________|<-._ ________ ; |__________| ; | life |
; ; ; ; always ^ ^. AKA'->| gratis | ; ; high ; |___________|
;is ; _______v ; ; '.AKA |________| ; ;primary focus ;
;subset ; | profit | ; ; 'v __________ ^ ; ;focus on on ;
;of ; |________| ; is ; | freeware | AKA ; ; ___v________ ;
; ; ^ ; opposite ; |__________|<----' ; | simplicity |<---------'
; ; main ; ; of ; ; |____________|
; ; goal is ; ; ; may be is ;
; ; ; '----------. ; opposite ;
; ; '----------. ; ; of ;
; ; _;__v_____;___________ ;
; '------------------>| proprietary software |<--------------'
'---------------------------->|______________________|
Knowledge graph illustrating basic relationships between various terms and groups related to free software.
{ Thanks to Ramon for calling this a "schizo graph" :D ~drummyfish }
Though unknown to common people, the invention and adoption of free software has been one the most important events in the history of computers -- mere technology consumers nowadays don't even realize (and aren't told) that what they're using consists and has been enabled possibly mostly by software written non-commercially, by volunteers for free, basically on communist principles. Even if consumer technology is unethical because the underlying free technology has been modified by corporations to abuse the users, without free software the situation would have been yet incomparably worse if Richard Stallman hadn't achieved the small miracle of establishing the free software movement. Without it there would probably be practically no alternative to abusive technology nowadays, everything would be much more closed, there would probably be no "open source", "open hardware" such as Arduino and things such as Wikipedia. If the danger of intellectual property in software wasn't foreseen and countered by Richard Stallman right in the start, the corporations' push of legislation would probably have continued and copyright laws might have been many times worse today, to the point of not even being able to legally write free software nowadays. We have to be very grateful that this happened and continue to support free software.
Richard Stallman, the inventor of the concept and the term "free software", says free software is about ensuring the freedom of computer users, i.e. people truly owning their tools -- he points out that unless people have complete control over their tools, they don't truly own them and will instead become controlled and abused by the makers (true owners) of those tools, which in capitalism are corporations. Richard Stallman stressed that there is no such thing as partially free software -- it takes only a single line of code to take away the user's freedom and therefore if software is to be free, it has to be free as a whole. This is in direct contrast with open source (a term discourages by Stallman himself) which happily tolerates for example Windows only programs and accepts them as "open source", even though such a program cannot be run without the underlying proprietary code of the platform. It is therefore important to support free software rather than the business spoiled open source.
Fun fact: in Spain there is a street named after free software.
Free software is not about privacy!* That would be quite misleading viewpoint. Free software, as its name suggests, is about freedom in wide sense, which includes the freedom of absolute control over one's devices that may ensure privacy and anonymity, but there are many more freedoms which free software stands for, e.g. the freedom of customization of one's tools or the general freedom of art -- being able to utilize or remix someone else's creation for creating something new or better. Software focused on privacy is called simply privacy respecting software.
The forefront non-profit organization promoting free software has since its invention been the Free Software Foundation (FSF) started by Richard Stallman himself alongside his GNU project. Nevertheless we must keep in mind that FSF doesn't equal free software, free software as a concept is bigger than its inventor or any organization, the idea -- just as for example political or religious ideas -- has since its birth been adopted with various modifications by many others, it is being expanded, improved, renamed and yes, even twisted and abused. Free software has spawned or influenced for example Debian, free culture, free hardware, FSFE, FSFLA, open $ource, suckless, copyfree, freedesktop and many others. FSF itself has become quite spoiled and political, but it has achieved sending out the message about sharing, collaboration and ethics, which at least a few people still try to keep following.
Is free software communism? This is a question often debated by Americans who have a panic phobia of anything resembling ideas of sharing and giving away for free. The answer is: yes and no. No as in it's not Marxism, the kind of evil pseudocommunism that plagued the world not a long time long ago -- that was a hugely complex, twisted violent ideology encompassing whole society which furthermore betrayed many basic ideas of equality and so on. Compared to this free software is just a simple idea of not applying intellectual property to software, and this idea may well function under some form of early capitalism. But on the other hand yes, free software is communism in its general form that simply states that sharing is good, it is communism as much as e.g. teaching a kid to share toys with its siblings.
Is free software an ideology/cult? Free software is a movement based on ethics of technology and its followers typically do hold strong opinions, so naturally there appear radicals strongly rejecting anything proprietary only out of principle, just like religious people for example refuse to eat certain kinds of food, i.e. the so called "freetards" are oftentimes made fun of and compared to "digital vegans". Nonetheless if we talk about free software USERS, more than 99% are moderate people who probably don't even know what free software means, and there are people in between -- still outnumbering the extremists -- who know free software and support it without being too radical. Richard Stallman himself plays along with the joke of "software as religion" and named himself the head of a parody "Church of Emacs". Again, however, we can't generalize behavior and culture of one group to the CONCEPT of free software and to other groups that have adopted the concept, most of free software is purely a mode of developing software and a voluntary relaxation of legal restrictions. Practically all computers on Earth work thanks to free software. Extremists appear everywhere and are always in minority but still, given that free software is unquestionably GOOD for the people, can we even claim that being an extremist at doing good is a bad thing to do? Perhaps we may end up arguing about the means of promoting free software, licenses and so on, but to speak in general means to speak only about the underlying commonly shared goal of sharing software, and that is good.
Fun fact: around 1991 Richard Stallman created the Free Software Song which starts with the lyrics: "Join us now and share the software; you'll be free, hackers." -- Stallman said he put the lyrics in the public domain. The melody is taken from Bulgarian folk song called Sadi Moma. The song has a very uncommon 7/8 rhythm that is not easy to follow, especially when singing at the same time, but Richard Stallman always follows it perfectly.
Free software was originally defined by Richard Stallman for his GNU project. The definition was subsequently adopted and adjusted by other groups such as Debian or copyfree and so nowadays there isn't just one definition, even though the GNU definition is usually implicitly assumed. However, all of these definition are very similar and are quite often variations and subsets of the original one. The GNU definition of free software is paraphrased as follows:
Software is considered free if all its users have (forever and without possibility of revoking) the legal and de facto rights to:
Note that as free software cares about real freedom, the word "right" here stands for a de facto right, i.e. NOT just a legal right -- legal rights (a free license) are required but if there appears a non-legal obstacle to those freedoms, truly free software communities will address them. Again, open source differs here by just focusing on legality, i.e. open source only cares about technically adhering to legalese while ignoring everything else.
To make it clear, freedom 0 (use for any purpose) covers ANY use, even commercial use or use deemed unethical by society or the software creator. Some people try to restrict this freedom, e.g. by prohibiting use for military purposes or prohibiting use by "fascists", which makes the software NOT free anymore. NEVER DO THIS. The reasoning behind freedom 0 is the same as that behind free speech or freedom of research: allowing any use doesn't imply endorsing or supporting any use, it simply means that we refuse to engage in certain kinds of oppression out of principle. Creator of software shouldn't be the authority deciding how the software can be used just as a scientist mustn't be the authority who decides how his discoveries will be used. We simply don't do this -- to address "wrong" use of technology is a matter of different disciplines such as philosophy.
Source code is usually defined as the preferred form in which the software is modified, i.e. things such as obfuscated, minified or compiled source code don't count as true source code.
Any software that is not free (as in freedom) is called proprietary, even if it is for example available free of charge. Alas, a lot of confusion surrounds free software terminology, and so let us give a table summarizing some of the key terms:
| type of software | free of charge? | source code available? | use+study+modify+share? |
|---|---|---|---|
| free (as in freedom), libre, open source, FOSS | yes | yes | yes |
| freeware, gratis, free as in beer | yes | ? | ? |
| public domain | yes | ? | yes |
| source available | ? | yes | ? |
| closed source | ? | no | no |
| proprietary | ? | ? | no |
The developers of Debian operating system have created their own guidelines (Debian Free Software Guidelines) which respect these points but are worded in more complex terms and further require e.g. non-functional data to be available under free terms as well (source), respecting also free culture, which GNU doesn't (source). The definition of "open source" is yet more complex even though in practice legally free software is eventually also open source and vice versa. The copyfree definition tries to be a lot more strict about freedom and forbids for example copyleft (which GNU promotes) and things such as DRM clauses (i.e. a copyfree license mustn't impose technology restrictions, even those seen as "justified", for similar reasons why we don't prohibit any kind of use for example).
One big issue related to free software and similar causes (e.g. free hardware) is slipping into the trap of only apparent freedom and acquiring false feeling of freedom without actually having real, practical freedom; that is having freedom given legally, "on the paper", which may however be de facto extremely hard or impossible to make use of practically in real life. Imagine for example a highly complex software that by its license gives everyone the right to modify it but in practice to make meaningful modifications one needs specialized hardware and deep knowledge and know-how of how the code really works -- this demonstrates for example the Android operating system. This particular example is called bloat monopoly, a modern phenomenon commonly used to mislead users into thinking they have freedom or that they support something ethical while in fact they don't (see also e.g. openwashing). Giving only this apparent freedom is how capitalism adjusted to the wave of free software, it is how businesses silently smother real freedom while pretending to embrace free software (which they rather call open source). For this we always have to evaluate practical freedom we have, i.e. whether, and with what difficulties, we can execute the four basic freedoms required by free software -- remember that all are essential and once even a single of the freedoms is lost, the whole software becomes completely proprietary and non-free.
One of possible measures of practical freedom is what we'll call a freedom distance. For any piece of software that comes with a free license (i.e. one that gives the four essential freedoms legally) let us define freedom distance as the average minimum distance to the nearest man that can PRACTICALLY execute ALL of the freedoms (taken over all people in the world). In other words it says how far you have to go to reach the freedom you are promised. As any metric it's a bit of a simplification, but while physical distances may seem to not matter much in the age of Internet, the measure contains in it embedded the number of people who have control over the piece of software, it says how centralized the control is and how difficult it will be to for example spot and remove malicious features. Large freedom distance means the freedom is far away, that you are relying on someone in another country to fix your software which of course is dangerous, even the Internet may get split, it is important for you to be able to execute your freedom locally (even if you're not doing it now, it is important that you COULD). It may also happen that the foreign maintainer of your software suddenly turns evil -- e.g. in pursuit of profit -- and then having someone close who can take over fixing and maintaining that software is key for freedom. From this point of view a freedom distance shorter than one's body is ideal -- it would mean that any single individual has complete control over his own tool.
Let's demonstrate it on a few examples:
Precursors to free software may reach as far back in history as we are willing to look. They may include for example ancient mathematicians sharing their equations with each other, engineers sharing plans, people sharing recipes for meals, and influence can possibly also come from the general ideas of communism (not to be confused with Marxism). In 20th century the early digital sharing communities on networks such as BBS and Usenet worked like free software communities "by default", without really articulating or naming the concept -- they shared software informally without licenses as back then it was believed copyright didn't even apply to software -- capitalists haven't yet had enough time to fuck everything up, but that slowly started to change with more commercialization of the brand new field and legal cases that would indeed establish that software was copyrightable.
Free software, in a form discussed here, was invented by Richard Stallman in the 1980s as a reaction to the corporate rape of computer industry. He cites his frustration with a proprietary Xerox printer driver as an initial impulse. The newly imposed secrecy of source code and limitations of legal rights for it strongly violated the hacker culture based on free sharing of code -- hackers valued openness and sharing so much that Stallman himself was even refusing to use password on his computer (source: the book Free as in Freedom). In 1983 he announced the now already legendary project called GNU -- one to implement a completely free as in freedom operating system, and later on the GNU Manifesto. The announcement described the system as "free", however still more in a sense of "not having to pay for permissions". Additionally in 1985 Stallman established the Free Software Foundation, a non-profit for promotion and support of free software, and this is when the term free software seems to have been clearly distinguished. In late 1980s Stallman wrote GPL, the major (and now one of the most frequent) free licenses. Other standard free licenses, such as the MIT or BSD, also appeared around this time. Before these standard licenses programs had to use custom ones, which was much harder and less legally safe.
In early 1990s a new project called Linux -- an operating system kernel -- joined GNU and as a final missing part completed its main goal. From now on it became practically possible to do one's computing solely with free software, and this would further be facilitated by the creation of various distributions, notably e.g. Debian. Also during mid 90s the BSD operating systems (FreeBSD, NetBSD and OpenBSD) were released under a free license as well, offering another alternative of a free Unix clone. While personal PCs were taken over by Windows and Mac due to aggressive marketing, practically all Internet servers chose some of the free operating systems and many professionals started to highly prefer them because the proprietary systems were, quite simply put, absolute garbage. Free software proved to objectively better.
Free software gained enough momentum to become a serious threat to capitalism and so opposition appeared, most notably Microsoft, caught red handed with the leak of so called Halloween documents in late 1990s, in which they discuss strategies for eliminating the threat of free software. Despite this free software couldn't be stopped and grew in popularity, which is apparent from the huge success of GNU/Linux and from the cases when very valuable software, such as the Doom engine or Blender, got released under free terms.
Later on free software inspired movements such as free culture (shortly after the year 2000) and the evil open-source fork (1998, a malicious response of business, a kind of "free software" minus ethics). Sister organizations to the original FSF were also established outside the US, notably FSFE (FSF Europe) and FSFLA (FSF Latin America) in 2001 and 2005 respectively.
Unfortunately around the year of our Lord 2010 (aka the year when everything started to go to shit) free software slowly gave way to the sinister "open source" tsunami which it would eventually get completely overshadowed by. This was really a part of the grand societal downfall, the time when dystopian ultracapitalism finally got to finishing off the last remnants of ethical values in society.
By 2024 free software is dead -- yes, FSF and a few other software "activists" are still around, but they don't bear any significance anymore, the free software movement disappeared just like hippies disappeared with 1960s. FSF has become just an email spamming organization supporting lesbian rights on the Internet, and those who truly believe in free software form a community that by its size is comparable to such insignificantly small groups as suckless for example. Everything is now "open $ource", which only means one thing: it is hosted on GitHub, and doesn't at all imply free code, available code, non-malicious features or even perhaps such a laughable thing as pursuit of freedom. Corruption, politics and free market have finally killed the free software movement, open $ource prevailed exactly as it was planned by capitalists at the meeting in 1998, and it has now redefined even the basic pillars of the four freedoms (partial openness, fair use or just source availability is now practically synonymous with "open source") -- just like for example "thou shalt not kill" was removed from Christianity because it wasn't convenient for the overlords -- and by this the fate of technology is sealed, free software seems to have only postponed the capitalist disaster by a few decades, which is still a remarkable feat. { It's been pointed out to me that even some project that call themselves "free" or "libre", such as "Libre"Boot, are in fact breaking the rules of freedom now, for example by including proprietary blobs. ~drummyfish }
The "free software alternatives" question is one that comes up often under capitalism: corporations try to forcefully keep users enslaved by proprietary environments while free software proponents and users themselves want to free the users with "alternatives" made as free software. A very common mistake for a free software newcomer to make is to try to "drop-in replace proprietary software with free software"; a user used to proprietary software and its ways just wants the programs he's used to, just "gratis, without ads and subscriptions etc.". This doesn't work, or only to a very small degree, because the whole proprietary world is made and DESIGNED from the ground up to allow user exploitation as much as possible, e.g. with embedding such thing like consumerism right into the design of visual elements of the software etc., i.e. proprietary vs free software is not just about a legal license, but whole philosophy of technology, asking things such as why are we so obsessed over "updates", why do we aim for maximalism or why are we freaking out about privacy. Trying to drop-in replace proprietary technology with 1 to 1 looking free software is like trying to replace whole capitalism with an "environment friendly capitalism" in which everything works the same except we have cars made of wood and skyscrapers made of recycled paper -- indeed, one sees that to get rid of the destructive nature of capitalism we really have to replace capitalism as such with all its basic concepts with something fundamentally different; and the situation is same with proprietary software. If you learned to do computing with proprietary software, you are not only being exploited by proprietary software, you also additionally learned to do computing the WRONG way -- solution is therefore not just in replacing the proprietary software, but also learning to do computing WELL.
For example most users nowadays want GUI in all programs, which is how they've been nurtured by capitalism, however we have to realize that a truly (de facto, not just legally) free software has to be minimalist and so most TRULY free software will mostly work only from the command line; a command line program is not necessarily harder or less comfortable to use (users are just nurtured to think so by capitalism), it is however inherently more free than a GUI one in all ways (not only by being more flexible, efficient, portable and non-discrimination, but also simpler and therefore e.g. modifiable by more people). We have to realize that a freedom respecting computing environment INHERENTLY LOOKS DIFFERENT from the proprietary one, the matter is NOT only about the license (free license is just a necessary condition to allow freedom under capitalism, however it is not a sufficient condition for freedom). People confronted with this fact for the first time usually start freaking out and panicking and they go full denial mode and start yelling NO THAT NOT TRUE THAT CAN'T BE TRUE, they erect a mental blocker and start desperately clutching onto ANY excuse at all they can find, they will start googling youtubers who say the opposite so they can remain in they sweet dreamlike state in which they don't have to abandon their favorite belowed Windows games and lovely pimped out GUI and LED keyboards they post on Twitter every day -- nevertheless this is 100% hard to swallow truth pill that is NECESSARY to be accepted if one wants to live in truth; not accepting this means choosing the way of comfortable self deceit of the eternal NPC. Some projects calling themselves "free" (or rather "open source") make the mistake (sometimes intentionally, exactly to e.g. more easily pull over more users from the proprietary land) of simply mimicking proprietary ways 1 to 1 -- see e.g. Fediverse ("free" facebook/twitter/etc.), Blender etc. -- these are technically/legally free, but not actually, de-facto free. While a short-sighted view tells us this wins more users from the proprietary platforms, in long term we see we are just rebuilding dystopias, only painted with brighter colors so as to make them look friendlier (and oftentimes this is exactly the aim of the authors). Transitioning to TRULY free platforms is harder -- one has to relearn basic things such as, as has been mentioned, working with command line rather than GUI -- but ultimately right as one really gets more freedom, however under capitalist pressure and nurturing it is a hard thing to do, requiring extorting a lot of energy to resist the pressures of society.
After some years dealing with software freedom (in serious ways, making money doesn't count) many -- including us -- realize that the "licensing" fuss and legal questions, though important, are the surface, shallow views of freedom; one that also gets exploited by many (see e.g. openwashing). Those who seek real freedom will sooner or later find themselves focusing on minimalism and simplicity, e.g. LRS, suckless, Bitreich, DuskOS etc. Going yet further, one starts to see the inherent interconnections of technology and whole society, and has to become interested also in social concepts, hence our proposal of less retarded society.
Function is a very elementary term in mathematics and programming, with a slightly distinct meaning in each of the both fields and further context: mathematical functions, practically speaking, map numbers to other numbers; a function in programming is similar but is rather seen as one of many subprograms of which the main program is composed. Well, that's a pretty simplified gist of it but it's roughly how matters stand. A more detailed explanation will follow.
Yet another attempt at a quick summary: imagine function as a miniature box. In mathematics you throw numbers (or similar object, for example sets) into the box and it spits out other numbers (or "objects"); the number that falls out always only depends on the number you throw in. So the box essentially just transforms numbers into other numbers. In programming a function is similar, it is also a box into which you throw numbers and can behave like the mathematical function, but the limitations are relaxed so the box can also do additional stuff, it may for example light up a light bulb; it may also remember things and sometimes shit out a different number when you throw in the same number twice -- sometimes the box is so fancy that it doesn't even need any input numbers anymore, it's just turned on with a button and it starts going around and doing stuff.
In mathematics functions can be defined and viewed from different angles, but it is essentially anything that assigns each member of some set A (so called domain) exactly one member of a potentially different set B (so called codomain). A typical example of a function is an equation that from one "input number" computes another number, for example:
`f(x) = x / 2
Here we call the function f and say it takes one parameter (the "input number") called x. The "output number" is defined by the right side of the equation, x / 2, i.e. the number output by the function will be half of the parameter (x). The domain of this function (the set of all possible numbers that can be taken as input) is the set of real numbers and the codomain is also the set of real numbers. This equation assigns each real number x another real number x / 2, therefore it is a function. (In the C programming language this function could be written as float f(float x) { return x / 2.0; }.)
We can naturally write input and output values of a function into a table, here is one for the function we just examined:
| x | f(x) |
|---|---|
| ... | ... |
| -2 | -1 |
| -1 | -0.5 |
| 0 | 0 |
| 1 | 0.5 |
| 2 | 1 |
| 3 | 1.5 |
| ... | ... |
And alongside this table we can also draw a plot to get a "graphical view" of our function -- we'll see this further below.
Now consider a function f2(x) = 1 - 1 / x. Note that in this case the domain is the set of real numbers minus zero; the function can't take zero as an input because we can't divide by zero. The codomain here is the set of all real numbers, however we see we can't ever get 1 as a result (which would require 1 / x = 0), so we say that the range of the function is the set of all real numbers minus the number 1. Here is a table:
| x | f2(x) |
|---|---|
| ... | ... |
| -2 | 1.5 |
| -1 | 2 |
| 0 | undefined |
| 1 | 0 |
| 2 | 0.5 |
| 3 | 0.666... |
| ... | ... |
Another common example of a function is the sine function that we write as sin(x). It can be defined in several ways, commonly e.g. as follows: considering a right triangle with one of its angles equal to x radians, sin(x) is equal to the ratio of the side opposing this angle to the triangle hypotenuse. For example sin(pi / 4) = sin(45 degrees) = 1 / sqrt(2) ~= 0.71. The domain of sine function is again the set of real number but its range is only the set of real numbers between -1 and 1 because the ratio of said triangle sides can never be negative or greater than 1, i.e. sine function will never yield a number outside the interval <-1,1>.
Note that these functions have to satisfy a few conditions to really be functions. Firstly each number from the domain must be assigned exactly one number (although this can be "cheated" by e.g. using a set of couples as a codomain), even though multiple input numbers can give the same result number. Also importantly the function result must only depend on the function's parameter, i.e. the function mustn't have any memory or inside state and it mustn't depend on any external factors (such as current time) or use any randomness (such as a dice roll) in its calculation. For a certain argument (input number) a function must give the same result every time. For this reason not everything that transforms numbers to other numbers can be considered a function.
Functions can have multiple parameters, for example:
`g(x,y) = (x + y) / 2
The function g computes the average of its two parameters, x and y. Formally we can see this as a function that maps elements from a set of couples of real numbers to the set of real numbers.
Of course function may also work with just whole numbers, also complex numbers, quaternions and theoretically just anything crazy like e.g. the set of animals :) However in these "weird" cases we generally no longer use the word function but rather something like a map. In mathematical terminology we may hear things such as a real function of a complex parameter which means a function that takes a complex number as an input and gives a real number result.
To get better overview of a certain function we may try to represent it graphically, most commonly we make function plots also called graphs. For a function of a single parameter we draw graphs onto a grid where the horizontal axis represents number line of the parameter (input) and the vertical axis represents the result. Basically we make a table of the function input and output values, like we have seen above, and the pairs of numbers in each row give us coordinates of points we will plot. For example plotting a function f(x) = ((x - 1) / 4)^2 + 0.8 may look like this:
|f(x)
2+
'.._ |
''--1+.____...--'
___,__,__|__,__,_____x
-2 -1 |0 1 2
-1+
|
-2+
|
If the function is continuous (like here) we also connect the plotted [*x*,*f(x)*] points to create a continuous curve (see also interpolation).
Plotting functions of multiple parameters is more difficult because we need more axes and get to higher dimensions. For functions of 2 parameters we can draw e.g. a heightmap or create a 3D model of the surface which the function defines. 3D functions may in theory be displayed like 2D functions with added time dimension (animated) or as 3D density clouds. For higher dimensions we usually resort to some kind of cross-section or projection to lower dimensions.
Functions can have certain properties such as:
f^(-1)(x) = x / 2, but f2(x) = x^2 is not bijective because e.g. both 1 and -1 give the result of 1.
f(x) = f(-x), i.e. the plotted function is symmetric by the vertical axis. Example is the cosine function.
-f(x) = f(-x), i.e. the plotted function is symmetric by the center point [0,0]. Example is the sine function.
In context of functions we may encounter the term composition which simply means chaining the functions. E.g. the composition of functions f(x) and g(x) is written as (f o g)(x) which is the same as f(g(x)).
Calculus is an important mathematical field that studies changes of continuous functions. It can tell us how quickly functions grow, where they have maximum and minimum values, what's the area under the line in their plot and many other things.
Mathematical functions can be seen as models of computation, i.e. something akin to an "abstract computer": the field studying such functions is called computability theory. Here we may divide functions into classes depending on how "difficult" it is to compute their result.
Among mathematical functions (here potentially under a more liberal interpretation) deserving a mention are for example:
f(x) = 1.
f(x) = x, just returns the input.
f(x) = a * x + b.
floor, ceil, ...)
sin): Moves up and down smoothly, models smooth oscillation.
cos): Same as sine but shifted on the x axis.
tan)
cot)
asin), arcus cosine (acos), arcus tangent (atan), ...
sinh)
cosh)
tanh)
coth)
asinh), hyperbolic acrus cosine (acosh), hyperbolic acrus tangent (atanh), ...
log or ln): Base is e (constant known as Euler's number).
log or log10): Base is 10.
log2): Base is 2.
sqrt), factorial, prime numbers, Fibonacci sequence, pseudorandom sequences, fractals, set operations etc.
f(x) = 3 * x^2 - 2 * x^3 for x between 0 and 1 (clamped elsewhere).
{ Playing around with plotting 2D functions (functions with 2 parameters) is guaranteed fun, you can create beautiful pictures with very simple formulas. I once created a tool for this (just some dirty page with JavaScript) and found quite nice functions, for example: gaussian_curve((x^2) mod (abs(sin(x + y)) + 0.001) + (y^2) mod (abs(sin(x - y)) + 0.001)) plotted from [-3,-3] to [3,3] (plot with amplitude set to range from white to black by given minimum and maximum in the given area). ~drummyfish }
Here are plots of some common and/or interesting unary functions:
2 .---------------. 2 .---------------. 3 .---------------. 4 .---------------. 2 .---------------.
| 1 | | _/ | | | | | | sign(x) |
1 +---------------| 1 + _/ x | 2 + sqrt(x) | 2 + ln(x) _| 1 + .-------|
| | | _/ | | ...| | _.--''" | | : |
0 + | 0 + _/ | 1 + _.--''' | 0 + .' | 0 + : |
| | | _/ | | : | | : | | : |
-1 + | -1 + _/ | 0 + | | -2 + ,' | -1 +-------' |
| | |_/ | | | | : | | |
-2 '---+---+---+---' -2 '---+---+---+---' -1 '---+---+---+---' -4 '---+---+---+---' -2 '---+---+---+---'
-2 -1 0 1 2 -2 -1 0 1 2 -1 0 1 2 3 -2 0 2 4 6 -2 -1 0 1 2
2 .---------------. 4 .---------------. 4 .---------------. 8 .---------------. 4 .---------------.
| \_ abs(x) _/ | | : | |: :| | : | | x^3 : |
1 + \_ _/ | 2 + : | 3 +'. x^2 .'| 6 + ,' | 2 + : |
| \_ _/ | | '--..| | : : | | 2^x : | | / |
0 + V | 0 + 1/x | 2 + '. .' | 4 + .' | 0 + .-' |
| | |''--. | | : : | | .' | | / |
-1 + | -2 + : | 1 + \ / | 2 + .' | -2 + : |
| | | : | | '-._.-' | |_____..-' | | : |
-2 '---+---+---+---' -4 '---+---+---+---' 0 '---+---+---+---' 0 '---+---+---+---' -4 '---+---+---+---'
-2 -1 0 1 2 -4 -2 0 2 4 -2 -1 0 1 2 -4 -2 0 2 4 -4 -2 0 2 4
2 .---------------. 2 .---------------. 3 .---------------. 3 .---------------. 2 .---------------.
| sin(x) = cos( | | cos(x) = sin( | | : tan(x): | | : cot(x): | | sqrt(1 - x^2) |
1 + _.-._ x-pi/2) | 1 +-._ x+pi/2) _| + : : | + : : | 1 + _.-._ |
|/ \ | | \ / | |: : | | : : | | / \ |
0 + \ | 0 + \ / | 0 + / | 0 + \ \ | 0 + : : |
| \_ _/| | \_ _/ | | : :| | : : | | |
-1 + '-' | -1 + '-' | + : : | + : : | -1 + |
| | | | | : : | | : : | | |
-2 '---+---+---+---' -2 '---+---+---+---' -3 '---+---+---+---' -3 '---+---+---+---' -2 '---+---+---+---'
0 pi 2pi 0 pi 2pi -pi -pi/2 0 pi/2 pi -pi -pi/2 0 pi/2 pi -2 -1 0 1 2
.---------------. .---------------. pi .---------------. 1 .---------------. 1 .---------------.
pi | | | | /2 | atan(x) .-""| | sin(x)^3 :": | | sin( ,: :\ |
/2 + asin(x) : | pi + : acos(x) | + .' | + : : | + 1/x) :|:' '-._|
| _.' | | '._ | | / | | : : | | ||| |
0 + _/ | + \_ | 0 + / | 0 +. .-' '| 0 + :|: |
| .' | | '. | | / | | : : | |_ |:| |
-pi + : | 0 + : |-pi + .' | + : : | + '-_ .:|: |
/2 | | | | /2 |__-' | | :_: | | \: :' |
'---+---+---+---' '---+---+---+---' '---+---+---+---' -1 '---+---+---+---' -1 '---+---+---+---'
-2 -1 0 1 2 -2 -1 0 1 2 -6 -3 0 3 6 -pi 0 pi -2 -1 0 1 2
8 .---------------. 12 .---------------. 1 .---------------. .---------------. .---------------.
| sinh(x) : | | : cosh(x) : | | tanh(x) .-""| | asin(sin(x)) | | tan(sin(x)) |
4 + / | 8 + : : | + .' | pi + .'. = tri(x) | pi + .-. |
| .' | | : : | | / | /2 |.' '. | /2 |.' '. |
0 + .-' | 4 + \ / | 0 + / | 0 + '. .| 0 + '. .|
| .' | | '-._.-' | | / | | '. .' | | '._.' |
-4 + / | 0 + | + .' |-pi + ' |-pi + |
| : | | | |__-' | /2 | | /2 | |
-8 '---+---+---+---' -4 '---+---+---+---' -1 '---+---+---+---' '---+---+---+---' '---+---+---+---'
-4 -2 0 2 4 -4 -2 0 2 4 -2 -1 0 1 2 0 pi 2pi 0 pi 2pi
4 .---------------. 3 .---------------. 4 .---------------. 4 .---------------. 1 .---------------.
| | | | | | : | | : : : : | |logistic(x).-""|
2 +\ / | 2 + gauss(x) = | 3 + x^x ,' | 2 + '_' : ,' | + = 1/(1+ .' |
| '---' | | e^-x^2 | | : | | '-' | | e^-x) / |
0 + 1/sin(x) = | 1 + .-. | 2 + : | 0 + _ gamma(x) |1/2 + / |
| csc(x) .---. | | .' '. | | .' | |: : | | / |
-2 + / \| 0 +--'' ''--| 1 + . ,' | -2 + : | + .' |
| | | | | | ''' | | : _ | |__-' |
-4 '---+---+---+---' -1 '---+---+---+---' 0 '---+---+---+---' -4 '---+---+---+---' 0 '---+---+---+---'
0 pi 2pi -2 -1 0 1 2 -1 0 1 2 3 -4 -2 0 2 4 -4 -2 0 2 4
1 .---------------. 2 .---------------. 2 .---------------. 1 .---------------. 1 .---------------.
| ... sin(sin( | | : | | x/(x^2 .-. | | .-._ | | /|saw(x)/| |
+.' '.sin(sin(| 1 + : .-. | 1 + +0.1) : \ | + : '''---..._| + / | / | |
|: : x)))) | | : / : | | : '-_| |: log(5*x)/x | |/ | / | |
0 + : | 0 + '-' : | 0 + : | 0 +: | 0 + | / | |
| : :| | 3x^2 - 2x^3 '.| |"-. : | |: | | | / | /|
+ '. .'| -1 + (smoothstep) :| -1 + \ : | +: | + | / | / |
| ''' | | :| | '-' | |: | | |/ |/ |
-1 '---+---+---+---' -2 '---+---+---+---' -2 '---+---+---+---' -1 '---+---+---+---' -1 '---+---+---+---'
0 pi 2pi -2 -1 0 1 2 -2 -1 0 1 2 0 3/2 3 0 pi 2pi 3pi 4pi
TODO: gauss(x) * sin(8x), (x^2)^x, square, ...
TODO: 2D plots
Programmers, being mere scum compared to mathematicians, define a function less strictly, even though some programming languages, namely functional ones, are still built around purely mathematical functions -- for distinction we call the "strictly mathematical functions" pure. In traditional languages functions may or may not be pure, a function here normally means a subprogram which can take parameters and return a value, just as a mathematical function, but it can further break some of the rules of mathematical functions -- for example it may have so called side effects, i.e. performing additional actions besides just returning a number (such as modifying data in memory which can be read by others, printing something to the screen etc.), or use randomness and internal states, i.e. potentially returning different numbers when invoked (called) multiple times with exactly the same arguments. These functions are called impure; in programming a function without an adjective is implicitly expected to be impure. Thanks to allowing side effects these functions don't have to actually return or take any value, their purpose may be to just invoke some behavior such as writing something to the screen, initializing some hardware etc. The following piece of code demonstrates this in C:
int max(int a, int b, int c) // pure function, returns the greatest of three numbers
{
return (a > b) ? (a > c ? a : c) : (b > c ? b : c);
}
unsigned int lastPresudorandomValue = 0;
unsigned int pseudoRandom(unsigned int maxValue) // impure function
{
lastPresudorandomValue = // side effect: working with global variable
lastPresudorandomValue * 7907 + 7;
return (lastPresudorandomValue >> 2) % (maxValue + 1);
}
In older languages functions were also called procedures or routines. Sometimes there was some distinction between them, e.g. in Pascal functions returned a value while procedures didn't.
Just as in mathematics, a function in programming may be recursive -- here we define recursion as a function that calls itself.
Hash is a number computed from given data in a chaotic way, which serves various useful purposes, e.g. for quick comparisons (instead of comparing big data structures we just compare their hashes) or mapping data structures to table indices.
Hash is computed by a hash function: one that takes data on input and outputs a number (the hash) that's in terms of bit width much smaller than the data itself, has a fixed size (number of bits) and which has additional properties such as being completely different from hashes of even very similar (but different) data. Thanks to these simple but very useful properties hashes enjoy a very wide range of uses in computer science -- they are frequently used for comparisons of bigger data such as documents or compiled programs, or in indexing structures such as hash tables which allow for quick search of data, and they also play a big role in cryptocurrencies and security, e.g. in computing digital signatures or storing passwords (for security reasons in databases of users we store just hashes of their passwords, never the passwords themselves). Hashing is exceptionally important and as a programmer you won't be able to avoid encountering hashes somewhere in the wild.
{ Talking about wilderness, hyenas have their specific smells that are determined by bacteria in them and are unique to each individual depending on the exact mix of the bacteria. They use these smells to quickly identify each other. The smell is kind of like the animal's hash. But of course the analogy isn't perfect, for example similar mixes of bacteria may produce similar smells, which is not how hashes should behave. ~drummyfish }
It's probably good to say we distinguish between "normal" hashes used for things such as indexing data and cryptographic hashes that are used in computer security and have to satisfy stricter mathematical criteria. For the sake of simplicity we will sometimes ignore this distinction in this article. Just know it exists.
It is generally given that a hash (or hash function) should satisfy the following criteria:
Hashes are similar to checksums but are different: checksums are simpler because their only purpose is checking data integrity, they don't have to show chaotic behavior or uniform mapping and they are often easy to reverse. Hashes also differ from database IDs: IDs are just sequentially assigned numbers that aren't derived from the data itself, they don't satisfy the hash properties and they have to be absolutely unique. The term pseudohash may also be encountered, it seems to be used for values similar to true hashes which however don't quite satisfy the definition.
{ I wasn't able to find an exact definition of pseudohash, but I've used the term myself e.g. when I needed a function to make a string into a corresponding fixed length string ID: I took the first N characters of the string and appended M characters representing some characteristic of the original string such as its length or checksum -- this is what I called the string's pseudohash. ~drummyfish }
Some common uses of hashes are:
Let's say we want a hash function for string which for any ASCII string will output a 32 bit hash. How to do this? We need to make sure that every character of the string will affect the resulting hash.
First thought that may come to mind could be for example to multiply the ASCII values of all the characters in the string. However there are at least two mistakes in this: firstly short strings will result in small values as we'll get a product of fewer numbers (so similar strings such as "A" and "B" will give similar hashes, which we don't want). Secondly reordering the characters in a string (i.e. its permutations) will not change the hash at all (as with multiplication order is insignificant)! These violate the properties we want in a hash function. If we used this function to implement a hash table and then tried to store strings such as "abc", "bca" and "cab", all would map to the same hash and cause collisions that would negate the benefits of a hash table.
A better hash function for strings is shown in the section below.
{ Reminder: I make sure everything on this Wiki is pretty copy-paste safe, from the code I find on the Internet I only copy extremely short (probably uncopyrightable) snippets of public domain (or at least free) code and additionally also reformat and change them a bit, so don't be afraid of the snippets. ~drummyfish }
Here is a simple and pretty nice 8bit hash, it outputs all possible values and all its bits look quite random: { Made by me. ~drummyfish }
uint8_t hash(uint8_t n)
{
n *= 23;
n = ((n >> 4) | (n << 4)) * 11;
n = ((n >> 1) | (n << 7)) * 9;
return n;
}
The *hash prospector* project (unlicense) created a way for automatic generation of integer hash functions with nice statistical properties which work by XORing the input value with a bit-shift of itself, then multiplying it by a constant and repeating this a few times. The functions are of the format:
uint32_t hash(uint32_t n)
{
n = A * (n ^ (n >> S1));
n = B * (n ^ (n >> S2));
return n ^ (n >> S3);
}
Where A, B, S1, S2 and S3 are constants specific to each function. Some nice constants found by the project are:
| A | B | S1 | S2 | S3 |
|---|---|---|---|---|
| 303484085 | 985455785 | 15 | 15 | 15 |
| 88290731 | 342730379 | 16 | 15 | 16 |
| 2626628917 | 1561544373 | 16 | 15 | 17 |
| 3699747495 | 1717085643 | 16 | 15 | 15 |
The project also explores 16 bit hashes, here is a nice hash that doesn't even use multiplication!
uint16_t hash(uint16_t n)
{
n = n + (n << 7);
n = n ^ (n >> 8);
n = n + (n << 3);
n = n ^ (n >> 2);
n = n + (n << 4);
return n ^ (n >> 8);
}
Here is a simple string hash, works even for short strings, all bits look pretty random: { Made by me. Tested this on my dataset of 70000 programming identifiers, got no collisions. ~drummyfish }
uint32_t strHash(const char *s)
{
uint32_t r = 11;
while (*s)
{
r = (r * 101) + *s;
s++;
}
r = r * 251;
r = ((r << 19) | (r >> 13)) * 113;
return r;
}
TODO: more
BONUS: Here is a kind of string pseudohash for identifiers made only of character a-z, A-Z, 0-9 and _, not starting with digit -- it may be useful for symbol tables in compilers. It is parameterized by length n, which must be greater than 4. It takes an arbitrary length identifier in this format and outputs another string, also in this format (i.e. also being this kind of identifier), of maximum length n - 1 (last place being reserved for terminating zero), which remains somewhat human readable (and is the same as input if under limit length), which may be good e.g. for debugging and transpiling (in transpilation you can just directly use these pseudohashes from the table as identifiers). In principle it works something like this: the input characters are cyclically written over and over to a buffer, and when the limit length is exceeded, a three character hash (made of checksum, "checkproduct" and string length) is written on positions 1, 2 and 3 (keeping the first character at position 0 the same). This means e.g. that the last characters will always be recorded, so if input identifiers differ in last characters (like myvar1 and myvar2), they will always give different pseudohash. Also if they differ in first character, length (modulo something like 64), checksum or "checkproduct", their pseudohash is guaranteed to differ. Basically it should be hard to find a collision. Here is the code: { I found no collisions in my dataset of over 5000 identifiers, for n = 16. ~drummyfish }
char numPseudohash(unsigned char c)
{
c %= 64;
if (c < 26)
return 'a' + c;
else if (c < 52)
return 'A' + (c - 26);
else if (c < 62)
return '0' + (c - 52);
return '_';
}
void pseudohash(char *s, int n)
{
unsigned char
v1 = 0, // checksum
v2 = 0, // "checkproduct"
v3 = 0, // character count
pos = 0;
const char *s2 = s;
while (*s2)
{
if (pos >= n - 1)
pos = 4;
v1 += *s2;
v2 = (v2 + 1) * (*s2);
v3++;
s[pos] = *s2;
pos++;
s2++;
}
if (v3 != pos)
{
s[1] = numPseudohash(v1);
s[2] = numPseudohash(v2);
s[3] = numPseudohash(v3);
}
s[n - 1] = 0;
}
Here are some example inputs and output strings:
"CMN_DES" -> "CMN_DES" "CMN_currentInstrTypeEnv" -> "CBcxrTypeEnvnst" "LONG_prefix_my_variable1" -> "L4kyvariable1y_" "TPE_DISTANCE" -> "TPE_DISTANCE" "TPE_bodyEnvironmentResolveCollision" -> "TxMJCollisionve" "_TPE_body2Index" -> "_TPE_body2Index" "_SAF_preprocessPosSize" -> "_RpwPosSizecess"
Internet (sometimes just the net, also serious business) is the grand, decentralized global network of interconnected computer networks that allows advanced, cheap, practically instantaneous intercommunication of people and computers and sharing of large amounts of data and information. Over just a few decades since its inception in 1970s it grew over biblical proportions, changed the society tremendously, shifted it to the information age and thereafter stands as possibly the greatest technological invention of our society. It is a platform for many services and applications such as the web, e-mail, internet of stinks, torrents, phone calls, video streaming, multiplayer games etc. Of course, once Internet became accessible to the common folk and turned to largest public forum on the planet, it has also become the largest dump of retards in history and, as always, capitalism turned the dream of Internet into a nightmare.
Before continuing it's important to make a clear distinction between the Internet as such and the Internet Revolution. The Internet in itself is a marvel of ingenuity and a good tool with great potential to help all the people, but the so called "Internet Revolution" was a disaster due to having a very bad, capitalist society in place, just like the Agricultural and Industrial revolutions presented a disaster for the people despite farming, engineering, mass production and automation being potentially good concepts in themselves. A knife is a tool, it can be used for good, but it's a bad tool in hands of a psychopath, and the same goes about any technology. Therefore we have to distinguish between the Internet alone (good) and the effects that Internet created in our dystopian society (bad).
{ For readers in the future: I witnessed this "revolution" first hand, I remember the world before Internet was common and can confirm it brought along the worst horrors I could imagine. ~drummyfish }
Sometimes we distinguish between lowercase i "internet", meaning a large computer network, and capital I "Internet", signifying the one majestic worldwide internet. As many great networks eventually interconnect with and become part of the "big" Internet, we now seldom pay attention to this distinction, in normal speech both "internet" and "Internet" typically stand for the big Internet.
Internet is built on top of protocols (such as IP, HTTP or SMTP), standards, organizations (such as ICANN, IANA or W3C) and infrastructure (undersea cables, satellites, routers, ...) that all together work to create a great network based on packet switching, i.e. a method of transferring digital data by breaking them down into small packets which independently travel to their destination (contrast this to circuit switching). The key feature of the Internet is its decentralization, i.e. the attribute of having no central node or authority so that it cannot easily be destroyed or taken control over -- this is by design, the Internet evolved from ARPANET, a project of the US defense department. Nevertheless there are parties constantly trying to seize at least partial control of the Internet such as governments (e.g. China and its Great Firewall, EU with its "anti-pedophile" chat monitoring laws etc.) and corporations (by creating centralized services such as social networks). Some are warning of possible de-globalization of the Internet that some parties are trying to carry out, which would turn the Internet into so called splinternet.
Access to the Internet is offered by ISPs (internet service providers) but it's pretty easy to connect to the Internet even for free, e.g. via free wifis in public places, or in libraries. By 2020 more than half of world's population had access to the Internet -- most people in the first world have practically constant, unlimited access to it via their smartphones, and even in poor countries capitalism makes these devices along with Internet access cheap as people constantly carrying around devices that display ads and spy on them is what allows their easy exploitation.
Initially the Internet was basically a purely technological marvel but since its wide spread that made it an inseparable part of our everyday lives it also turned into a phenomenon of interest to many other fields such as psychology and sociology. By now the number of various Internet communities and subcultures has grown so much that a sociologist can probably spend a whole career studying only Internet communities, of which many have risen and fallen over the decades. Studying Internet culture has become a hobby to many, something akin to an alternative to traveling in real life -- the Internet is quite like an another planet now, with new countries and nations coming to existence, with their own laws and even language dialects forming in the virtual Universe. In the 2000s the situation was basically this: older people didn't know the Internet slang and young people did. By 2020s everyone knows the Internet, it's just that different people are familiar with different corners of it, with different flavors of memes, slang and in-jokes, some are Facebook and Twitter normies, some are TikTokers, some are 4channers, redditors, Usenet and IRC boomers, quake multiplayer enjoyers, some are suckless hackers, some fancy deeper underground such as Vidlii, Bitreich, LRS, gopher, encyclopedia dramatica, some love netstalking, darknet exploration, data archeology and hoarding. And so on and so forth.
The following are some statistics about the Internet as of early 2020s: there are over 5 billion users world-wide (more than half of them from Asia and mostly young people), it is estimated 63% people worldwide use the Internet with the number being as high as 90% in the developed countries. Most Internet users are English speakers (27%), followed by Chinese speakers (25%). It's also estimated over 50 billion individual devices connected, about 2 billion websites (over 60% in English) on the web, hundreds of billions of emails are sent every day, average connection speed is 24 Mbps, there are over 370 million registered domain names (most popular TLD is .com), Google performs about 7 billion web searches daily (over 90% of all search engines).
It's been observed that 99% of the Internet is porn and recent studies suggest that 50% of the Internet is AI slop. That would mean only -49% of the Internet is actual normal content.
PRO TIP: you should download and/or print your own offline Internet (or maybe we should rather say offline web). Collect your favorite websites and other resources (gopher holes, Usenet threads, images, ...) and make a single dense PDF out of them. Process each page so that it's just plain text, remove all graphics and colors, unify the font, make the font small and decrease margins so that you fit as much as possible on a single page to not waste paper. For many pages, like Wikipedia, a small script will be able to do this automatically; the uglier pages may just be edited manually. An easy approach is for example to convert the pages to plain HTML that just contains paragraphs and heading of different levels, then copy-pasting this to LibreOffice, globally editing the font and auto-generate things like table of contents and page numbers, then exporting as PDF. You can even make a script that contains the list of pages you want to scrap so that you can make a newer print a few years later. Once you have the PDF, print it out and have your own tiny offline net :) It will be useful when the lights go out, it's a physical backup of your favorite sites (the PDF, as a byproduct, is also a single-file backup in electronic form), something no one will be silently censoring under your hands, and it's also just nice to read through printed pages, the experience is better than reading stuff on the screen -- this will be like your own 100% personalized book with stuff you find most interesting, in a form that's comfortable to read. You should also download your favorite and essential websites and other files for offline use, this way you'll be able to browse even when the Internet collapses and/or if you're just somewhere without connection, plus you'll have a backup in case they go offline themselves. Here is a KISS script template that does the downloading (it can also at the same time serve as a list of your favorite websites), also feel free to improve it (e.g. compress/minimize the downloaded files etc.):
#!/bin/bash rm -rf offline mkdir offline echo " http://favoritesite1.com https://favoritesite2.com/page1.html http://favoritesite3.com/favoritefile1.txt http://favoritesite4.org/coolimage.jpg " | shuf | wget -i - -E -e robots=off -nc -nd -U "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)" --tries=3 -k -w 1 -P offline
As of 2024 the Internet is dead, like whole society, killed by capitalism -- take a look at the alternatives to the Internet down below.
Internet is NOT real life and as Ashley Jones said: you cannot apply real life logic on the Internet. If you try to behave on the Internet like you behave in real life you are retarded and don't understand how Internet works. If that's the case please fuck off the Internet.
{ Some sites with Internet history: https://www.zakon.org/robert/internet/timeline/, https://www.freesoft.org/CIE/Topics/57.htm. ~drummyfish }
It goes without saying that even though in retrospect it looks like the Internet just came to be one day, it wasn't indeed so -- we have to remember large communication networks existed for a long time and were often used in ways very similar to the Internet, even for silly things like playing games (e.g. chess used to be played over snail mail and even telegraph). Before electronic networks there were networks such as paper mail and optical telegraphs. Electricity opened the door to numerous new, much improved networks, such as the electrical telegraph (~1840), phone and fax networks (~1880) that even allowed sending images (since early 1900s thanks to Belinographe, used mainly by newspapers), radio broadcasts (circa first half of 20th century) and TV broadcasts (~1930). Some of the later networks were very similar to the World Wide Web from user perspective, and they were quite advanced and widely used at the time when Internet was just in its infancy -- for example teletext (~1970) allowed people to browse graphical pages on their TVs, BBS and Usenet networks were already digital computer networks (accessed through dialup modems) allowed people to chat, discuss on forums, roleplay, play games and share files, Minitel was the most successful Internet like network that worked in France in the 1980s etc. Perhaps not to much surprise visions of Internet as we know it appeared beforehand for example in sci-fi, one particularly famous such work is the 1956 book called A Logic Named Joe.
The Internet itself evolved from ARPANET, a network designed by US department of defense; ARPANET started to be developed in 1969 (with first plans appearing in 1966), fueled by Cold War rivalry with the Soviet Union. Of course, this network wasn't intended to become what the Internet is today, no one could probably have foreseen the future, it was just another military project -- as such, ARPANET was designed to be decentralized so as to be robust, i.e. there was no central node of the network which would be an easy target for enemies in a war. ARPANET was revolutionary by utilizing so called packet switching (idea published in a paper in 1961), i.e. any data sent over the network were split into small data packets that would travel through the network independently, each one possibly by different path, and would be reassembled into the whole once they all arrived at the destination (again, this helped keep the network robust -- if one path was destroyed, packets would just find another path). This is in contrast to traditional circuit switching used until then e.g. in telephone networks (circuit switching basically just means that direct connections are established between nodes that want to communicate at given time).
In April 1969 the first RFC ("request for comments") document was published (back then wrote with typewriter) -- RFCs would become a standard type of documents for discussing the design and improvements of ARPANET and later the Internet between the network engineers and scientists -- in RFCs new standards and protocols would be suggested, defined and discussed. 29 October 1969 is seen as a historical moment for ARPANET because at that day first data were sent through it from University of California -- it was a letter "L" (a whole word "LOGIN" was supposed to be sent but the computer crashed somewhere at "G"). In November of this year the first permanent ARPANET connection was established between University of California and Stanford Research Institute and shortly after a 4 node network was established.
By 1971 there were 15 ARPANET nodes. In 1974 allegedly the first use of the word "Internet" appeared in the specification of the TCP protocol by Cerf et al. The TCP/IP protocol they published would become a key part of the Internet -- even today these protocols are the foundation of the Internet. By 1977 ARPANET had about 60 nodes.
In 1983 there were more than 500 registered hosts and in 1984 the number surpassed 1000. Also in 1984 the DNS (domain name system) was introduced -- this would allow network nodes to have "human friendly names" like mycomputer.com instead of just numeric addresses. In 1985 the first domain name was registered -- it was symbolics.com. In 1987 the number of hosts was around 10000. In 1989 this was already 100000.
In 1990 ARPANET project was officially ended to let the network, now mostly known as the Internet, live and be developed further mostly by the private sector. In this year EFF (Electronic Frontier Foundation), a major international non-profit that would help overlooking the Internet, was also founded. Due to the exploding popularity the Internet started to run out of IP addresses in early 1990s which was temporarily fixed by so called CIDR with long term plans to transition to bigger IPv6 addresses.
Probably the biggest milestone in Internet history was the emergence of the World Wide Web -- also www or just "the web" -- in 1989 by Tim Berners-Lee who was at the time working at CERN in Europe (i.e. if we see the US as the inventor of the Internet, the Europe is who made it widespread and famous). The Web was based on the idea of documents (webpages) written in a special language (HTML), all interconnected via clickable links (so called hypertext) viewed with a program called web browser. Web's popularity was also helped by the fact that the programs made by Berners-Lee were released to the public domain so that anyone could jump on the web for free, even use it commercially without any fees and so on. And of course, a prerequisite for wide popularity was the presence of the cheap personal computer. Shortly after its invention web competed with other similar services based on similar ideas, most notably gopher, however some time in the mid 1990s the web took over and would quickly became by far the most prominent Internet service which would go on to make the Internet mainstream. In 1994 w3c (World Wide Web Consortium) was established to be the main organization standardizing the web. The web would gradually push all other networks and competing service -- such as BBSes, Usenet and gopher -- to the deepest underground. Of course, having become the Earth's largest public forum, the web would also ultimately become what would kill the Internet because all the major powers (read corporations and states) would quickly jump in to abuse it for their own propaganda, marketing, spying, manipulation, crowd control, cyberattacks and so on. This would still take some time, until around 2005 the web was great, very decentralized with plethora of useful personal web pages. People also weren't shitscared by security hysteria yet, https still wasn't the default, everyone would put his photos online along with his name, address and phone number, you could literally visit elementary school websites and find which children went to which class and so on -- no, nothing bad happened, it was all fine. However after this -- with the onset of so called web 2.0 (more bloated web) and so called social networks -- the downhill ride would start. It would still take around anther decade for the web to die completely, until 2010 the web still kept part of its original glory, but after 2015 it all shattered. After 2020 the web is but a corpse inhabited by grandma's playing games on facebook while being bombarded by ads and the corpse of what used to be the web is just being kicked further to the ground by new capitalist cyberweapons such as the "AI".
Nowadays not only the web but the Internet as a whole is dying by hardcore capitalism, becoming greatly censored, regulated, split (so called splinternet) and controlled by corporations who are absolutely killing the old decentralized, free as in freedom Internet that was developed by free software enthusiasts, nerds, oldschool hackers, free speech promoters, by universities, scientists and researches in transparent ways, through the RFCs. It is important to remember what it once used to be so that perhaps one day we can see the true Internet return.
Here is the Internet over time in numbers:
| year | ~inet servers | ~websites | ~domains | ~% inet users (glob.) |
|---|---|---|---|---|
| 1969 | 4 | |||
| 1970 | 10 | |||
| 1975 | 100 | |||
| 1980 | 200 | |||
| 1985 | 2000 | 1 | ||
| 1990 | 300000 | 1 | 9300 | |
| 1995 | 2000000 | 23000 | 71000 | 1 |
| 2000 | 100000000 | 7000000 | 40000000 | 7 |
| 2005 | 350000000 | 100000000 | 100000000 | 16 |
| 2010 | 700000000 | 300000000 | 200000000 | 30 |
| 2015 | 1000000000 | 1000000000 | 300000000 | 43 |
See also https://solar.lowtechmagazine.com/2015/10/how-to-build-a-low-tech-internet/.
Internet overtook the world thanks to providing numerous services very cheaply, at very large scales and/or with highly elevated parameters such as minimal delay or great bandwidth. This is crucial to many industries who couldn't do without such a network, however to individuals or even smaller organizations Internet is frequently just a tool of comfort and convenience -- they could exist without the Internet, just a little less comfortably. As the Internet is becoming more and more monitored, controlled, overcrowded and censored, we may start to consider the less comfortable alternatives as good enough ways to actually regain some advantages in other ways, e.g. more freedom of expression, more robust network (independence of the Internet infrastructure), technological independence etc. We must remember that services allowed by the Internet, such as long distance communication, search of information or playing games still exist without the Internet, just separated or somehow suffering a few disadvantages; nevertheless these disadvantages may be bearable and/or reduced, e.g. by adjusting ourselves to the limitations (if our communication is slower, we'll simply write longer messages with more effort and information put in etc.) or combining these alternative services in a clever way. Additionally we can make use of the lessons learned from the Internet (e.g. cleverly designed protocols, steganography, broadcasts, digital data, ...) and apply them to the alternative networks. Let us now list a few alternatives to the Internet:
See also The Island network.
Would the Internet exist in less retarded society? Is it compatible with it? And if so, how different would it be?
It's very clear the Internet as seen today was shaped by capitalism and thus reflects its (anti)values such as consumerism, censorship ("privacy", "security"), wasteful maximalism (maximum bandwidth, maximum speed, ...), centralized control (DNS, content delivery networks, ...) etc. This is what would have to change in less retarded society whose values are mostly opposite: minimalism, simplicity, selflessness, non-commerce, absolute openness, slow life etc. In a better form the Internet is indeed completely compatible with ideal society, it is a tool that can be used for the good. Many of the above mentioned alternative and non-traditional ways of data exchange could be used to make Internet "less retarded".
As always nothing can be predicted with certainty, but our Internet would likely be more diverse e.g. in protocols and media used for connecting computers which would depend on location: in some areas radio and cables could be used, in other places data mules, light or sound could do better, and highly expensive and complicated methods like satellites would undoubtedly be reduced to minimum or even eliminated. Computer users wouldn't fancy an always online paradigm like they do now, personal computers mostly wouldn't even use wifis (though they could easily receive radio broadcasts) -- common people would carry their personal computers along with the data they need, and would only connect to local Internet hubs if they need to send an email or download some additional data. Two way radio communication would potentially only be used to connect far away hubs if cables would be too expensive, and even so the transmission wouldn't likely be sustained 24/7, it could only happen for example once a day. As a result Internet would be slower, data from far away would be cached in local hubs and Internet communities would be more local (in the spirit of BBS networks in the 80s and 90s), more self sufficient and more independent. Internet would blend together with all other networks and so for example radio broadcasts would become part of it, enabling easier, further reaching and more efficient one way transmission of data about weather, news and so on. Instantaneous high-bandwidth communication, such as video calls, would be possible on shorter distances but challenging and sometimes impossible over large distances, but society wouldn't depend on them like it does today.
No and if you think you do, you're an immeasurable retard. It is enough to connect to the Internet once a week with a speed of like 1 kbps, you literally don't need anything more.
TODO: moar
Interpolation (inter = between, polio= polish) means computing (usually a gradual) transition between some specified values, i.e. creating additional intermediate points between some already existing points. For example if we want to change a screen pixel from one color to another in a gradual manner, we use some interpolation method to compute a number of intermediate colors which we then display in rapid succession; we say we interpolate between the two colors. Interpolation is a very basic mathematical tool that's commonly encountered almost everywhere, not just in programming: some uses include drawing a graph between measured data points, estimating function values in unknown regions, creating smooth animations, drawing vector curves, digital to analog conversion, enlarging pictures, blending transition in videos and so on. Interpolation can be used to generalize, e.g. if we have a mathematical function that's only defined for whole numbers (such as factorial or Fibonacci sequence), we may use interpolation to extend that function to all real numbers. Interpolation can also be used as a method of approximation (consider e.g. a game that runs at 60 FPS to look smooth but internally only computes its physics at 30 FPS and interpolates every other frame so as to increase performance). John Carmack even said in one video that "everything is an interpolation problem if you have enough data" -- the claim was made in context of artificial intelligence and it can really be argued that supervised learning, for example, is really just a very fancy way of interpolation between the training data points. So all in all: for programmers interpolation is one of the most basic and essential things to learn.
The opposite of interpolation is extrapolation, an operation that's extending, creating points OUTSIDE given interval (while interpolation creates points INSIDE the interval). Both interpolation and extrapolation are similar to regression which tries to find a function of specified form that best fits given data (unlike interpolation it usually isn't required to hit the data points exactly but rather e.g. minimize some kind of distance to these points).
There are many methods of interpolation which differ in aspects such as complexity, number of dimensions, type and properties of the mathematical curve/surface (polynomial degree, continuity/smoothness of derivatives, ...) or number of points required for the computation (some methods require knowledge of more than two points).
.----B _B _.B _-'''B-.
| .' .' .'
| _-' / :
| .' .' /
A----' A' A-' _.A'
nearest linear cosine cubic
A few common 1D interpolation methods.
The base case of interpolation takes place in one dimension (imagine e.g. interpolating sound volume, a single number parameter). Here interpolation can be seen as a function that takes as its parameters the two values to interpolate between, A an B, and an interpolation parameter t, which takes the value from 0 to 1 -- this parameter says the percentage position between the two values, i.e. for t = 0 the function returns A, for t = 1 it returns B and for other values of t it returns some intermediate value (note that this value may in certain cases be outside the A-B interval, e.g. with cubic interpolation). The function can optionally take additional parameters, e.g. cubic interpolation requires to also specify slopes at the points A and B. So the function signature in C may look e.g. as
float interpolate(float a, float b, float t);
Many times we apply our interpolation not just to two points but to many points, by segments, i.e. we apply the interpolation between each two adjacent points (a segment) in a series of many points to create a longer curve through all the points. Here we are usually interested in how the segments transition into each other, i.e. what the whole curve looks like at the exact locations of the points.
Nearest neighbor is probably the simplest interpolation (so simple that it's sometimes not even called an interpolation, even though it technically is). This method simply returns the closest value, i.e. either A (for t < 0.5) or B (otherwise). This creates kind of sharp steps between the points, the function is not continuous, i.e. the transition between the points is not gradual but simply jumps from one value to the other at one point.
Linear interpolation (so called LERP, not to be confused with LARP) is probably the second simplest interpolation which steps from the first point towards the second in a constant step, creating a straight line between them. This is simple and good enough for many things, the function is continuous but not smooth, i.e. there are no "jumps" but there may be "sharp turns" at the points, the curve may look like a "saw".
Cosine interpolation uses part of the cosine function to create a continuous and smooth line between the points. The advantage over linear interpolation is the smoothness, i.e. there aren't "sharp turns" at the points, just as with the more advanced cubic interpolation against which cosine interpolation has the advantage of still requiring only the two interval points (A and B), however for the price of a disadvantage of always having the same horizontal slope at each point which may look weird in some situations (e.g. multiple points lying on the same sloped line will result in a curve that looks like smooth steps).
Cubic interpolation can be considered a bit more advanced, it uses a polynomial of degree 3 and creates a nice smooth curve through multiple points but requires knowledge of one additional point on each side of the interpolated interval (this may create slight issues with the first and last point of the sequence of values). This is so as to know at what slope to approach an endpoint so as to continue in the direction of the point behind it.
Besides these we may potentially use many other functions, curves and splines (for example Akima spline, Steffen spline and so on).
The above mentioned methods can be generalized to more dimensions (the number of dimensions are equal to the number of interpolation parameters) -- we encounter this a lot e.g. in computer graphics when upscaling textures (sometimes called texture filtering). 2D nearest neighbor interpolation creates "blocky" images in which pixels simply "get bigger" but stay sharp squares if we upscale the texture. Linear interpolation in 2D is called bilinear interpolation and is visually much better than nearest neighbor, bicubic interpolation is a generalization of cubic interpolation to 2D and is yet smoother that bilinear interpolation.
TODO: simple C code pls, maybe linear interpolation without floats
In programming input/output (I/O or just IO) refers to communication of a computer program with the outside environment, for example with the user in real world or with the operating system. Input is information the program gets from the outside, output is information the program sends to the outside (note that "outside" doesn't mean just world physically outside the computer case but anything outside the program's inner state, i.e. for example a file on the disk is also "outside"). I/O is a basic and very important term as it separates any program to two distinct parts: the pure computational system (computation happening "inside", in a sort of black box) and I/O which interconnects this system through an interface with the real world and hence makes it useful -- without I/O a program would be practically useless as it couldn't get any information about the real world and couldn't present the computed results. This separation also allows us to define technology by focusing on the interfaces rather than the computer parts themselves, which turns out to be very good for various reasons (for details refer to the article on interfaces). In hardware there exists the term "I/O device" (vaguely synonymous with "peripheral device"), based on the same idea -- I/O devices serve to feed input into and/or get output from a physical computer, for example keyboard is an input device and monitor is an output device (a computer without I/O devices would be useless just as a program without I/O capabilities).
Note that I/O is not just about communication with a human user, it also means e.g. communication over network, reading/writing from/to files etc.
It is possible to have no input (e.g. a demo), but having no output at all probably makes no sense (see also write-only).
I/O presents a challenge for portability!* While the "pure computation" part of a program may be written in a pure platform-independent language such as C (and can therefore easily be compiled on different computers) and may be quite elegant, the I/O part gets more ugly.
This is because I/O is inevitably messy: an abstract, portable I/O library really tries to do the impossible task of unifying all wildly differing physical computers and their architectures under some simple functions; for example consider an I/O library will offer a function such as drawPixel(x,y,color) that draws a pixel to the screen -- how do we make this work for all computers? What value is color here, is it RGB, a color index, HDR value? What if a computer doesn't allow writing to arbitrary parts of screen coordinates because it lack a frame buffer, or what if such operation is painfully slow there (some computers may just want to write pixels sequentially in possibly varying orders we can't predict)? WHAT IF the computer doesn't even have a raster screen but instead has a vector screen? Even such things as files residing in a tree of directories are something that's highly established but not necessarily the only way a computer may work, some computers may for example support files but not directories, how does our library take this into account? How do we deal with file names with very weird characters, what if someone makes a file system where file names are actually rich text or where files aren't places in directories but are rather points in 3D space or something? So an I/O library has to inevitably make many assumptions about what a "normal" computer looks like and what will likely help it operate fast etc. It has to decide how to deal with unsupported things, for example if we try to display color on a black and white display will it cause an error or will we try to somehow approximate the color just with shades of gray? And of course with new I/O devices appearing (VR, brain interfaces, ...) the library will have to be constantly updated. So the I/O part of the program will usually require some platform specific library or a library with many dependencies; for example to display pictures on screen one may use SDL, OpenGL, Linux framebuffer, CSFML, X11, Wayland and many other libraries, each one handling I/O a bit differently. Whatever library you choose, it may be unavailable on some other platform, so the program won't run there. Some hardware platforms (e.g. many game consoles) even have their own exclusive I/O library, use of which will just tie the program to that single platform. There are programming languages and libraries that try to provide platform-independent I/O, but as said such approach is limited as it has to assume some common features that will be available everywhere; for example C has a standard platform-independent I/O library stdio, but it only allows text and binary input/output, for anything advanced such as graphics, sound and mouse one has to choose some 3rd party library. Unix philosophy also advises to only use text I/O if possible, so as to "standardize" and tame I/O a bit, but then again one has to choose what communication protocol/format to use etc., so the problem just shifts from standardizing library API to standardizing protocols. So generally I/O is a problem we have to deal with.
How to solve this? By separating I/O code from the "pure computation" code, and by minimizing and abstracting the I/O code so that it is easily replaceable. Inexperienced programmers often make the mistake of mixing the pure computation code with I/O code -- it is then very difficult to replace such I/O code with different I/O code on a different platform. See portability for more detail. Also if you don't have to, avoid I/O altogether, especially if your project is a library -- for example if you're writing a 3D rendering library, you do NOT actually need any I/O, your library will simply be computing which pixels to draw and what color they should have, the library doesn't actually have to write those pixels to any screen, this may be left to the user of the library (this is exactly how small3dlib works).
Also remember the ancient Unix wisdom: "Text is universal interface".
I/O also poses problems in some programming paradigms, e.g. in functional programming.
TODO: code example
Lambda calculus is an extremely simple (one of the simplest possible), low-level mathematical system capable of performing computation with mathematical functions, and can in fact be used to describe and carry out any conceivable computation. Lambda calculus provides a theoretical basis for functional programming languages and is a model of computation just like for example the Turing machine or interaction nets -- lambda calculus has in fact exactly the same computational power as a Turing machine, which is the greatest possible, and so these systems are alternatives to one another. Lambda calculus can also be viewed as a primitive programming language, however its immense simplicity (for example the lack of even such basic concepts as numbers) doesn't allow its pure form to be used for practical programming, it is more of a mathematical tool for studying computers theoretically, constructing proofs etc. The system is a result of the search for the most minimal systems capable of computation, just like the most essential physics equations emerge from searching for the most elementary rules of our Universe. Nevertheless anything that can be programmed in any classic programming language can in theory be also programmed in lambda calculus.
While Turing machines use memory cells as the medium supporting computation -- which closely imitates the "number crouching" of real life computers -- lambda calculus instead performs computation solely by simplifying an expression made of pure mathematical functions -- that means there are no global variables or side effects (the role of memory is essentially replaced by the expression itself, the lambda expression is both the program and its memory at the same time). It has to be stressed that the functions in question are mathematical functions, also called pure functions, NOT functions we know from programming (which can do all kinds of nasty stuff). A pure function cannot have any side effects such as changing global state and its result also cannot depend on any global state or randomness, the only thing a pure function can do is return a value, and this value has to always be the same if the arguments to the function are same. In addition to this the pure mathematical functions are yet much simpler than those we encounter in high school, there are no algebraic operators or numbers, just symbols.
(For the sake of simplicity we'll rely on pure ASCII text. Let the letters L, A and B signify the Greek letters lambda, alpha and beta.)
Lambda calculus is exceptionally simple in its definition, but it may not be so simple to grasp. Most students don't get it the first time, so don't worry :)
In lambda calculus function have no names, they are what we'd call anonymous functions or lambdas in programming (now you know why they're called lambdas).
Computations in lambda calculus don't work with numbers but with sequences of symbols, i.e. the computation can be imagined as manipulating the text string of the program itself with operations that can intuitively just be seen as "search/replace". That is we start with a program (text) that subsequently gets transformed by simple rules over and over before reaching a final form -- the result of the computation. If you know some programming language already, the notation of lambda calculus will seem familiar to functions you already know from programming (functions, their bodies, arguments, variables, ...), but BEWARE, this will also confuse you; functions in lambda calculus are a little different (much simpler) than those in traditional languages; e.g. you shouldn't imagine that variables and function arguments represent numbers -- they are really just "text symbols", all we're doing with lambda calculus is really manipulating text with very simple rules. Things like numbers, their addition etc. don't exist at the basic level of lambda calculus, they have to be implemented (see later). This is on purpose (feature, not a bug), lambda calculus is really trying to explore how simple we can make a system to still keep it as powerful as a Turing machine.
In lambda calculus an expression, also a lambda term or "program" if you will, consists only of three types of syntactical constructs:
For example (La.(Lb.x)) x is a lambda term while xLx..y is not.
Brackets can be left out if there's no ambiguity. Furthermore we need to distinguish between two types of variables:
Every lambda term can be broken down into the above defined three constructs. The actual computation is performed by simplifying the term with special rules until we get the result (similarly to how we simplify expression with special rules in algebra). This simplification is called a reduction, and there are only two rules for performing it:
A function in lambda calculus can only take one argument. The result of the function, its "return value", is a "string" it leaves behind after it's been processed with the reduction rules. This means a function can also return a function (and a function can be an argument to another function), which allows us to implement functions of multiple variables with so called currying.
For example if we want to make a function of two arguments, we instead create a function of one argument that will return another function of one argument. E.g. a function we'd traditionally write as f(x,y,z) = xyz can in lambda calculus be written as (Lx.(Ly.(Lz.xyz))), or, without brackets, Lx.Ly.Lz.xyz which will sometimes be written as Lxyz.xyz (this is just a syntactic sugar).
This is all we need to implement any possible program. For example we can encode numbers with so called Church numerals: 0 is Lf.Lx.x, 1 is Lf.Lx.fx, 2 is Lf.Lx.f(fx), 3 is Lf.Lx.f(f(fx)) etc. Then we can implement functions such as an increment: Ln.Lf.Lx.f((nf)x), etc.
Let's take a complete example. We'll use the above shown increment function to increment the number 0 so that we get a result 1:
(Ln.Lf.Lx.f((nf)x) (Lf.Lx.x) application (Ln.Lf.Lx.f((nf)x) (Lf0.Lx0.x0) A-conversion (rename variables) (Lf.Lx.f(((Lf0.Lx0.x0)f)x) B-reduction (substitution) (Lf.Lx.f((Lx0.x0)x) B-reduction (Lf.Lx.fx) B-reduction
We see we've gotten the representation of the number 1.
TODO: C code
Licar (short for libre car), also known as the best racing game ever made, is a fully public domain, free software and free culture 3D racing game by drummyfish, inspired mostly by the proprietary game Trackmania. Licar was made in similar fashion to Anarch (another major game by the same guy) but is a little more bloated: it is a fully 3D game made with small3dlib and tinyphysicsengine and although it's not the most minimalist piece of software under the sun, it is still very much KISS, extremely portable, not using any third party libraries etc. The git repo is currently at http://git.coom.tech/drummyfish/Licar; version 1.0 of the game was released on 25.06.2025 after 329 commits and didn't immediately receive as much Internet attention as Anarch because it wasn't "promoted" as much (the author no longer desires much attention for the creation, he feels he already has enough eyes on him). The development of Licar was conducted purely with free software (GIMP, Blender, GNU/Linux, vim, ...) and relatively old computers (mainly Thinkpad X200).
{ Some retard complained the game is "unprofessional" for giving an offensive warning during compilation on Windows. Well, if you haven't noticed, the game IS unprofessional, the developer doesn't get paid, so it can give whatever messages it wants you fucking pussy. ~drummyfish }
The game's features include a fully 3D, completely deterministic physics, lovely soulful software rendering, replays, ghost cars and custom maps (written in a plain ASCII text format). The base package comes with 5 standard, 5 tiny and 2 bonus maps. There are now also mods, such as one for making tool assisted runs. Like Trackmania, the game is built purely around the concept of a time attack run, there are no opponents on the track (except for a potential collisionless ghost), no car damage or upgrades, just pure driving skill and ticking clock.
Licar fulfilled drummyfish's lifelong dream to make a Trackmania clone, because he used to love the game and then had to abandon it as part of his decision to quit proprietary software. The project also gave him an opportunity to showcase his libraries and demonstrate some of the LRS principles on a bigger project -- although the game isn't truly an LRS ideal, it still shows how powerful minimalism can be, even when applied to a relatively mainstream vision of what a video game is. By this it can potentially and hopefully reach more normies.
Just like Anarch, Licar adheres to basic LRS programming practices, for example it is fully written in C99, is completely public domain under CC0, uses no build system, no third party libraries, doesn't rely on standard library, doesn't use floating point and embeds its configuration and assets right in the source code (except for optional music and external data file). The whole game was made completely from scratch, including all assets, the text font, recording own musical samples for custom sound font for the soundtrack etc. The whole code has around 25 thousand lines of code. Needless to say the game is very portable end efficient as a result: the compiled binary (including embedded assets) usually weights around 300 kB, the program runs with less than 500 kB RAM on CPUs clocking even around 100 MHz. It was even run on Pokitto, albeit in an extremely limited way.
Licar is wholly written in C99 and only uses small3dlib (S3L) and tinyphysicsengine (TPE) as libraries -- apart from these no other libraries are used (not even standard library, except for using fixed size integers from stdint.h). The code is a single compilation unit, i.e. everything is implemented as header files (including S3L and TPE) that are included by a frontend which is then the only file to compile (no need for manual linking, build systems and whatnot). Of course specific frontends have to use some kind of I/O library to deliver interaction with the player, but these are not hard dependencies of the game itself, only of a specific frontend -- several frontends are implemented, including SDL2, CSFML and X11. Frontends are very simple as they're only required to implement extremely basic functions such as a pixel drawing function, key press checking function and a few others. The game was successfully compiled and played under GNU/Linux, Win$hit, OpenBSD, on Raspberry Pi, in web browser and even on very weak devices such as Pokitto and ESPBoy, albeit in a very limited "tech demo" way. When counting raw lines (wc -l), all code (including frontends etc.) totals around 25000 lines of code, whilst only the pure game code (only header files) has around 21000 lines.
No floating point is ever used in the source code, everything (including 3D rendering and 3D physics) is implemented with 32 bit fixed point.
Graphics: like with Anarch, rendering to actual screen is realized through a frontend-defined pixel drawing function that's used by the game code to render everything from GUI and text to the 3D view. RGB565 (65536 colors) is used as a color format, with the option to turn on RGB332 (256 colors) as well. All images are embedded in the source code and stored in 64x64 resolution in indexed format (except for sky images which are effectively composed of 2x2 normal images to give a higher resolution). The car 3D model is also embedded in source code and was initially created with Blender. The models of map blocks are created in code. Textures are mapped to blocks automatically by something akin to a "uber projection", i.e. the vertex UV coordinates are derived from the geometric coordinates, and the slope of the triangle decides whether a wall or floor texture should be applied. When loading a map, its 3D model is created and invisible triangles are culled away (which is a little time consuming and makes bigger maps take longer to load). The map model triangles are then sorted so that the map is split into 64 (4x4x4) chunks -- only nearest 8 chunks of the map are being rendered at any time. Far away chunks are cheaply drawn as a very primitive "LOD", simply a flat-colored 2D half-transparent square. All transparency is handled by dithering. Text is drawn using a custom simple, vector, "segmented-display-like" font whose data are embedded in the source code.
Physics: physics is deterministic and is always calculated at 30 ticks per second regardless of rendering FPS is, interpolation is additionally applied to smooth the animation out for rendering. Internally the car is composed of 5 spheres (4 wheels and the body) and is technically a soft body, but the shape is iteratively "stiffened" so that it appears as a rigid body. The relative position of the spheres is used to determine the car's orientation which is then applied to the 3D model for rendering. The map's shape in the physics world is modeled by a sort of signed distance function to handle collisions with the car.
Audio: all audio is in very simple 8 bit 8 KHz mono format, KISS. Sound effects are all generated procedurally. The game comes with a manually created background music track stored in raw format in a separate file, which can be played by the frontend if it can and is willing to -- simpler frontends can just ignore music.
And finally for some more uncategorized details. Maps are written in a plain text mini-language that specifies where to place individual map blocks, what material and transformation they shall have etc. The process of loading a map includes reading the text format and transforming it into the internal binary representation wherein blocks are sorted so as to make block lookups fast via binary search (this is crucial for resolving collisions as we need to quickly check the car's nearest blocks). Replays are similarly stored in a plain text format -- each replay record takes up 16 bits and stores a change in input along with ticks since the last record (if the bits don't suffice to encode the ticks, a redundant no-change record is simply inserted). All these text data (i.e. mainly maps and replays) are stored in a virtual data file -- behind the scenes this files consists of the internal data file (one containing the basic maps, compiled right in the binary) and an optional external data file, which on platforms with filesystems is a normal file that can be edited to add more maps etc. Almost everything in the game is optional and can be turned off so that it's possible to play it on any kind of potato -- there can be no sound, texturing, no file system, no color display etc.
TODO: some reflections n shit here, when the time comes
Line is one of the most primitive and basic geometric shapes, it is straight, continuous, infinitely long and infinitely thin. A finite continuous part of a line is called line segment, though in practice we sometimes call line segments also just lines. Assuming normal, finite dimensional non-curved space/geometry without any obstacles etc., the shortest path between any two distinct points always lies on a line, which is also the only line that goes through both of these points.
Line is a one dimensional shape, i.e. any of its points can be directly identified by a single number -- the signed distance from a certain point on the line. But of course a line itself may exist in more than one dimensional spaces (just as a two dimensional sheet of paper can exist in our three dimensional space etc.).
{ In my favorite book Flatland line segments, being the most primitive shape, represent women. ~drummyfish }
/ | \ .' / ________ | \ .' / | \ .' / | \ .'
some lines, in case you haven't seen one yet
Mathematically lines can be defined by equations with space coordinates (see analytic geometry) -- this is pretty important for example for programming as many times we need to compute intersections with lines; for example ray casting is a method of 3D rendering that "casts lines from camera" and looks at which objects the lines intersect. Line equations can have different "formats", the two most important are:
y = k * x + q where x and y are space coordinates, k is the slope of the line and q is an offset. See examples below for more details.
Xn = Pn + t * Dn where Xn is nth coordinate (x, y, z, ...), Pn is nth coordinate of some point P that lies on the line, Dn is nth coordinate of the line's direction vector and t is a variable parameter (plugging in different numbers for t will yield different points that lie on the line). DON'T PANIC if you don't understand this, see the examples below :)As an equation for line segment we simply limit the equation for an infinite line, for example with the parametric equations we limit the possible values of t by an interval that corresponds to the two boundary points.
Example: let's try to find equations of a line in 2D that goes through points A = [1,2] and B = [4,3].
Point-slope equation is of form y = k * x + q. We want to find numbers k (slope) and q (offset). Slope says the line's direction (as dy/dx, just as in derivative of a function) and can be computed from points A and B as k = (By - Ay) / (Bx - Ax) = (3 - 2) / (4 - 1) = 1/3 (notice that this won't work for a vertical line as we'd be dividing by zero). Number q is an "offset" (different values will give a line with same direction but shifted differently), we can simply compute it by plugging in known values into the equation and working out q. We already know k and for x and y we can substitute coordinates of one of the points that lie on the line, for example A, i.e. q = y - k * x = Ay - k * Ax = 2 - 1/3 * 1 = 5/3. Now we can write the final equation of the line:
`y = 1/3 * x + 5/3
This equation lets us compute any point on the line, for example if we plug in x = 3, we get y = 1/3 * 3 + 5/3 = 8/3, i.e. point [3,8/3] that lies on the line. We can verify that plugging in x = 1 and x = 4 gives us [1,2] (A) and [4,3] (B).
Now let's derive the parametric equations of the line. It will be of form:
`x = Px + t * Dx
`y = Py + t * Dy
Here P is a point that lies on the line, i.e. we may again use e.g. the point A, so Px = Ax = 1 and Py = Ay = 2. D is the direction vector of the line, we can compute it as B - A, i.e. Dx = Bx - Ax = 3 and Dy = By - Ay = 1. So the final parametric equations are:
`x = 1 + t * 3
`y = 2 + t * 1
Now for whatever t we plug into these equations we get the [x,y] coordinates of a point that lies on the line; for example for t = 0 we get x = 1 + 0 * 3 = 1 and y = 2 + 0 * 1 = 2, i.e. the point A itself. As an exercise you may try substituting other values of t, plotting the points and verifying they lie on a line.
This section is a collection of formulas and equations related to lines and line segments.
First let's take a look at lines in 2D. Consider two dimensional plane. Let L be a line (or line segment) going from point L1 = [L1x,L1y] to point L2 = [L2x,L2y]. Let dx = L2x - L1x and dy = L2y - L1y. Let K be another line (or line segment). Let P = [Px,Py] be a point.
length(L) = sqrt(dx^2 + dy^2). The same goes for a line in 3D.
[L1,L2,P] goes clockwise or counterclockwise. This can also determine if the point lies exactly on the line (i.e. lies on neither side).
angle = atan(dy / dx), but watch out for division by zero).
TODO: 3D lines
Drawing lines with computers is a subject of computer graphics. On specific devices such as vector monitors this may be a trivial task, however as most display devices nowadays work with raster graphics (pixels!)), let's from now on focus only on such devices. It is worth spending some time on optimizing your line drawing function as it constitutes a very common operation -- imagine that you will for example be using it for wireframe rendering of a large 3D scene which will require rasterizing tens of thousands lines each frame -- in this case a fast line drawing function can significantly improve your FPS.
There are many algorithms for line rasterization. They vary in attributes such as:
.
XXX XX .aXa
XX XX lXa.
XX XX .lXl
XXX XXX .aal
XX XX lXa.
XX XXX .aXl
XX XX a.
pixel subpixel subpixel accuracy
accuracy accuracy + antialiasing
One of the most basic line rasterization algorithms is the DDA (Digital differential analyzer), however it is usually better to use at least the Bresenham's line algorithm which is still simple and considerably improves on DDA by not requiring multiplication or division (slow operations) and by only using integers (no floating point).
If you just super quickly need to draw something resembling lines for debugging purposes or anything, you may just draw a few points between the two endpoints (idea: make a recursive function that takes point A and B, average them to get a middle point M, draws all three points and then recursively call itself on A and M and then on M and B, until the points are close enough -- with integers only the line will probably be warped as we get accumulating rounding errors in the middle point). You may just do something super dirty like interpolate 1000 points between the endpoints with using floating point and draw them all. Just don't use this in anything serious I guess :)
Let's now take a more serious closer look at line drawing and how the above mentioned algorithms work: consider we want to draw a line between pixels A = [ax,ay] and B = [bx,by]. Let's also define dx = bx - ax and dy = by - ay.
The naive approach that comes to newcomer's mind is usually this: iterate x from ax to bx and at each step draw the pixel [x, ay + dy * (x - ax) / dx]. This has many problems: obviously we are using many slow operations here such as multiplication and division, but most importantly we will in many cases end up with holes in the line we draw. Consider e.g. a line from [0,0] to [2,10] -- we will only draw 3 pixels (for x = 0, 1 and 2), but the whole line is actually 10 pixels high in vertical direction, so we at the very least need those 10 pixels. What's more, consider dx = 0, our algorithm will crash on division by zero. This just falls apart very quickly.
The most common way to deal with this shit is to always convert the line to some simple subcase (by somehow juggling, swapping and flipping the coordinates), usually a line going from left to right under a degree between -45 and 45 degrees (i.e. abs(dx) >= abs(dy)). With such a line we now may do what we couldn't before, i.e. just iterate x by 1 and at each step compute the corresponding y. Once we have these coordinates we somehow convert them back to the space of the original line and draw them.
Furthermore algorithms improve this on the basis of observation that really while stepping along the x line we don't have to compute y from scratch, we are just deciding whether y stays the same as in previous step or whether it moves by 1 pixel, so drawing a line now boils down to making one yes/no decision at each step. It turns out this decision can be made using only simple integer operations.
Bresenham's algorithm is based on the following idea: our line has a certain slope s = dy / dx; this slope for the common case (described above) will be between -1 and 1. At each step we move 1 pixel horizontally (x) and s (some fractional part) pixels vertically. We keep accumulating this vertical shift (often called an error) and once it jumps over 1, we jump in the vertical (y) direction and so on. E.g. if our line is 10 pixels wide (dx) and 3 pixels tall (dy), our slope is s = 3/10; now we start drawing pixels and our error is 3/10, then 6/10, the 9/10 and then 12/10, jumping over 1, which tells us we have to shift vertically (after this we subtract 1 from the current error so we will continue with 2/10). Now to get rid of fractions (floats) we may simply multiply everything by dx; in our case by 10, so we keep adding error 3/10 * 10 = 3 and instead of comparing the error to 1, we compare it to 1 * 10 = 10.
All in all, here is a comfy line drawing function based on the above described principle, i.e. needing no floating point, multiplication or division:
void drawLine(int ax, int ay, int bx, int by)
{
int *x = &ax, *y = &ay,
stepX = -1 + 2 * (ax <= bx),
stepY = -1 + 2 * (ay <= by);
int dx = stepX == 1 ? (bx - ax) : (ax - bx);
int dy = stepY == 1 ? (by - ay) : (ay - by);
if (dy > dx)
{ // swap everything
y = &ax; x = &ay;
stepX ^= stepY; stepY ^= stepX; stepX ^= stepY;
dx ^= dy; dy ^= dx; dx ^= dy;
}
int steps = dx + 1;
bx = dx / 2; // use bx as error accumulator
while (steps)
{
drawPixel(ax,ay);
steps--;
*x += stepX;
bx += dy;
if (bx >= dx)
{
bx -= dx;
*y += stepY;
}
}
}
To add antialiasing here you wouldn't just draw one pixel at each step but two, right next to each other, between which you'd distribute the intensity in the ratio given by current error.
For computer logs see logging.
Logarithm (from Greek "logo arithmos", roughly "ratio/word number", often shortened to log, lg or ln) is a very important mathematical function telling us to what power a number has to be raised to in order to obtain another number; i.e. in the language of mathematics it is the inverse function to exponentiation. Logarithms are enormously important and useful: for example they allow fast and efficient multiplication and division of numbers (see e.g. sliding rule), solving certain kinds of equations but also, very notably, they introduce logarithmic scales -- a type of alternative measuring scales (to the traditional linear scales found on rulers etc.) in which steps are not spaced by constant distance but by constant ratio, and it turns out this is exceptionally handy for measuring and plotting various values (such as loudness, earthquake intensity etc.). This is because in nature it often happens that the step to "the next level" is not an additive constant, but rather some ratio of previous step (or imagine a video game where leveling up each subsequent level takes more and more experience, let's say three halves of that required for the previous one). So dealing with logarithms sort of takes us from the realm of additions and differences to one where multiplications and ratios rule.
Human senses are known to often perceive logarithmically (and this is exploited in lossy compression algorithms) -- one of the best examples are musical tones: what we hear as an increase in pitch by one semitone is actually a frequency that's 12th root of 2 TIMES increased frequency of the previous one. Our sensation of time passing or visual perception of brightness is also similarly non-linear. Interestingly some studies even suggested that "logarithmic thinking" is possibly more natural to our brains and only at school we're forced to adopt the traditional "linear thinking". However it might be, the first confrontation (normally during high school) with the mathematics of logarithms usually scares people off and average IQs never fully grasp them (because they "don't need it in real life"), but they're really not hard, just require some getting used to. To anyone dealing with math in any way (including programmers) logarithms are absolutely required basic knowledge, don't try to avoid them.
Logarithms were introduced in 1614 by John Napier (white male).
Different kinds of logarithms exist, distinguished by their base: every logarithm has a base, so we talk about "base 10 logarithm", "base 2 logarithm" etc. (note: base in this context does NOT signify the numeral system base, it's just a name for the number that gets raised to some power). The base is written as a subscript; here we'll write base N logarithm simply as logN (log10, log2 etc.). You may see logarithm written without the base, which either means some implicit base is assumed (often 10 or e, see below) or that the base doesn't matter.
Logarithm is thus not a single function but rather a class of functions. Alternatively you MAY imagine logarithm as a single function of two arguments: the input number x and the base. However conventionally we prefer to view logarithms with different bases as different functions of one argument, perhaps because it rarely happens we need the base to be variable (quite often the base doesn't even matter and it's only a convention of choosing one), and fewer variables means more simplicity, which is always a positive.
Now finally for the proper definition: base N logarithm of number x gives number y, which we write as
`logN(x) = y
so that the following holds:
`N^y = x
NOTE: Please don't confuse the function N^x with x^N (variable in exponent vs variable in base); inverse function of the former is logarithm N whereas the inverse of the latter is Nth root. These are similar and even the graphs of logarithm and Nth root look similar, but they aren't the same.
So answering the question "What's the base N logarithm of number x?" means answering "N to WHAT power gives x?". Of course we know that both N and y don't have to be just integers, but can be any real number (including fractions, negative numbers etc., however excluding both being zero!)), so logarithm is a continuous function, but we also know that (in the realm or real numbers) the operation of raising anything to a power can't ever yield a negative number (and neither zero, unless the base itself was zero), so logarithm is only defined for positive numbers.
NOTE: there exist generalizations such as complex logarithms and it's also possible to have logarithms with bases smaller than 1, but for the sake of simplicity we'll now assume only real number logarithms with a base greater than 1 (which, however, may still be a non-integer).
A small graph will make the best demonstration:
^ y
4 +
|
3 +
| ___...''' log2(x)
2 + __--''
| _.-'
1 + .' _____ log10(x)
| / ...----''''''''
----+---|'''|---|---|---|---|--> x
0| :1 2 3 4
| ::
-1 + :
| :
Here we can see log2(x) and log10(x) plotted, things to observe are mainly these:
logN(x) is a graph of function N^x flipped by the 45 degree axis because logarithm is an inverse of that function (it switches the x and y axes).
N^1 = N.
x = 1. Again this is logical: to get values smaller than 1 we have to raise N to a negative power (which makes it a reciprocal fraction).
x = 0 from the right. This represents the fact that raising 1/N to higher and higher powers gets us closer and closer to zero, but we never get there.
By bases some important logarithms are:
log2(x) for example says how many bits we need to represent x different values, or how many times we can split number x in halves, which is important for computing time complexity.
And here is a small table of some logarithm values to further aid making a picture of it all (ln(x) is natural logarithm):
x | ln(x) | log2(x) | log10(x) |
|---|---|---|---|
| 0 | ? | ? | ? |
| 0.5 | -0.693147 | -1.000000 | -0.301030 |
| 1 | 0.000000 | 0.000000 | 0.000000 |
| 1.5 | 0.405465 | 0.584963 | 0.176091 |
| 2 | 0.693147 | 1.000000 | 0.301030 |
| 2.5 | 0.916291 | 1.321928 | 0.397940 |
| 3 | 1.098612 | 1.584963 | 0.477121 |
| 3.5 | 1.252763 | 1.807355 | 0.544068 |
| 4 | 1.386294 | 2.000000 | 0.602060 |
| 4.5 | 1.504077 | 2.169925 | 0.653213 |
| 5 | 1.609438 | 2.321928 | 0.698970 |
| 5.5 | 1.704748 | 2.459432 | 0.740363 |
| 6 | 1.791759 | 2.584963 | 0.778151 |
| 6.5 | 1.871802 | 2.700440 | 0.812913 |
| 7 | 1.945910 | 2.807355 | 0.845098 |
| 7.5 | 2.014903 | 2.906891 | 0.875061 |
| 8 | 2.079442 | 3.000000 | 0.903090 |
| 8.5 | 2.140066 | 3.087463 | 0.929419 |
| 9 | 2.197225 | 3.169925 | 0.954243 |
| 9.5 | 2.251292 | 3.247928 | 0.977724 |
| 10 | 2.302585 | 3.321928 | 1.000000 |
One of the most important properties of logarithms, which you absolutely MUST burn into your brain right now, is that logarithm of a product equals sum of logarithms and logarithm of a quotient equals difference of logarithms, i.e.:
`logN(a * b) = logN(a) + logN(b)
and
`logN(a / b) = logN(a) - logN(b)
Why is this awesome? Well, because now if we can somehow quickly compute logarithm of a number -- for example with the help of precomputed tables, or even just approximately reading it off of the function plot -- we can very quickly multiply or divide numbers simply by looking up the logarithm of each and then adding them or subtracting them (which is not as time consuming as doing multiplication or division) and then mapping the logarithm of the result back. This can be used both by computers and humans to optimize the speed of calculations; in fact this is how the sliding rule works. This way raising a number to a power or finding its root can also be simplified to multiplication or division. (NOTE: someone smart could say we might as well have a precomputed table for multiplication, but that would be a much bigger table due to the fact that we'd need a value for any TWO input numbers, logarithm has just one).
Other important formulas with logarithms include these:
logN(a^b) = b * logN(a) (simplifies exponentiation to multiplication)
logA(b) * logB(a) = 1
logB(x) = logA(x) * 1/logA(B) (allows transforming logarithms between bases)
logN(N) = 1
logN(1) = 0
N^logN(x) = x
logN(N^x) = x
To get back to the logarithmic scales for a moment: these are scales whose value at each step increases not by a constant added number, but by multiplying the value of the previous step by some fixed fraction. In graphs such scale may be used on the x or y axis or both, depending on the need -- imagine for instance we were about to plot some exponentially increasing phenomenon, i.e. something that over each period of time (such as a year) grows by some fixed PERCENTAGE (fraction). Example may be the Moore's law stating that the number of transistors in integrated circuits doubles every two years. Plotting this with linear scales we'll see a curve that very quickly shoots up, turning steeper and steeper, creating a very inconvenient, hard to read graph. If instead we used logarithmic scale on the y axis (number of transistors), we'd get a nice straight line! This is because now as we're moving by years on the x axis, we are jumping by orders of magnitude on the y axis, and since that is logarithmic, a jump by order of magnitude shift us a constant step up. This is therefore very useful for handling phenomena that "up closer" need higher resolution and "further away" rather need more more space and bigger "zoom out" on detriment of resolution, such as the map of our Universe perhaps.
| | 2^x / | / 2^x
5 + | _/ x 16 + _/
| | / | /
4 + | _/ 8 + _/ __
| / / | / _--'''
3 + | _/ _--''' 4 + _/ _--'' x
| / / _--'' log2(x) | / _-'' _____
2 + | _/ _-'' 2 + _/ _-' __---''''
| / / _-' |/ _' _--' log2(x)
1 +'_/ _' 1 + / _/
|/ / : '
--+--+--+--+--+--+--+--+--+- ..+--+--+--+--+--+--+--+-
0 | 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8
| 2^x | | / | | 2^x /
5 + | | x _/ 16 + | _/ x
| | | / | / /
4 + / | _/ log2(x) 8 + | _/
| | / / | / / ___
3 + | | _/ 4 + | _/ __---'''
| / / / | _/ / _.' log2(x)
2 + | | _/ 2 + / _/ _.'
| / / / | / /
1 +' .'_/ 1 + _/ _/
: ' / :/ /
..+--+--+--+--+--+--+--+- ..+--+--+--+--+--+--+--+-
1 2 4 8 16 32 64 128 1 2 4 8 16 32 64 128
Graphs of functions 2^x, x and log2(x) with various combinations of linear and logarithmic (base 2) scales on x and y axes: linear, logarithmic y, logarithmic x and both logarithmic (log-log). Notice how one of the curves is always "straightened".
It won't come as a surprise that we'll find the logarithm function built in most of the popular programming_languages, most often present as part of the standard math library/module. Make sure to check which base it uses etc. C for example has the functions log(x) (natural logarithm), log10(x) and log2(x) under math.h -- if you need logarithm with different base, the simple formula given somewhere above will serve you to convert between arbitrary bases (also shown in an example below).
Should you decide for whatever bold reason to implement your own logarithm, consider first your requirements. If integer logarithm suffices, the straightforward "brute force" way of searching for the correct result in a for loop is quite usable since the number of iterations can't get too high (as by repeated exponentiation we quickly cover the whole range of even 64 bit integers). In C this may be done as follows (we have to watch out for overflows that could get us stuck in an infinite loop; this could also be addressed by using division instead of multiplication, but division can be very slow):
unsigned int logIntN(unsigned int base, unsigned int x)
{
unsigned int r = 0, n = base, nPrev = 0; // nPrev to detect overflow
while ((n <= x) & (n > nPrev))
{
nPrev = n;
n *= base;
r++;
}
return r;
}
If we don't insist on having the base a variable it's better to have it constant, the function will most likely get faster (passing one fewer argument, compiler can optimize expression with the constant etc.) -- especially log2 can be optimized by using a bit shift and being able to simplify everything like this:
unsigned int logInt2(unsigned int x)
{
unsigned int r = 0;
while (x > 1)
{
x >>= 1;
r++;
}
return r;
}
As always, look up tables may help create extremely fast versions for the price of some memory.
Mainstream way of implementing floating point logarithm is probably through Taylor series and similar infinite series such as (for natural logarithm):
`ln(x) = 2 * ((x-1)/(x+1) + 1/3 * ((x-1)/(x+1))^3 + 1/5 * ((x-1)/(x+1))^5 + ...)
Here this formula is used to implement a somewhat workable floating point natural logarithm and general base logarithm (a bit dirty due to hardcoded constants, but can be a start):
double logFloatE(double x)
{
double r = 0;
if (x > 2) // for larger values precision decreases
return logFloatE(x * 3.0/4.0) - logFloatE(3.0/4.0);
x = (x - 1) / (x + 1);
for (double i = 1; i < 8; i += 2) // 8 arbitrarily chosen
{
r += x / i;
x *= x * x;
}
return 2 * r;
}
double logFloatN(double base, double x)
{
return logFloatE(x) / logFloatE(base);
}
As for approximations: unfortunately good ones are often plagued by narrow interval of convergence. Attempts at construction of a function resembling logarithm may perhaps start with a similarly shaped function 1 - 1/x, then continue by pimping it up and adding correcting expressions until it looks cool. This may lead for example to the following expression: { Made by me. ~drummyfish }
`log10(x) ~= 3.0478 + 0.00001 * x - 205.9 / (x + 100) - (1233 * x + 10) / (625 * (x + 1) * x)
It's not very precise but the advantage is that it looks reasonable on a wide interval from 0 up to many thousands: before x gets to higher hundreds the error is somewhere around 3%, then around 2000 gets to some 10% and around 10000 to approx 20% where it then seems to stay for a very long time.
Should you have the pow (or even just exp) function at hand (which can itself be approximated), you could likely use it to implement floating point logarithm also through binary search with delta, Newton's method or something similar.
Mechanical computer (simple ones also being called mechanical calculators) is a computer that uses mechanical components (e.g. levers, marbles, gears, strings, even fluids ...) to perform computation (both digital and analog). Not all non-electronic computers are mechanical, there are still other types too -- e.g. computers working with light, biological, quantum, pen and paper computers etc. Sometimes it's unclear what counts as a mechanical computer vs a mere calculator, an automaton or just an instrument -- here we will consider the term in a very wide sense. Mechanical computers used to be used in the past, mainly before the development of vacuum tubes and transistors that opened the door for much more powerful computers. However some still exist today, though nowadays they are usually intended to be educational toys, they are of interest to many (including us) as they offer simplicity (independence of electricity and highly complex components such as transistors and microchips) and therefore freedom. They may also offer help after the collapse. While nowadays it is possible to build a simple electronic computer at home, it's only thanks to being able to buy highly complex parts at the store, i.e. still being dependent on corporations; in a desert one can much more easily build a mechanical computer than electronic one. Mechanical computers are very cool.
{ Britannica 11th edition has a truly amazing article on mechanical computers under the term Calculating Machines: https://en.wikisource.org/wiki/1911_Encyclop%C3%A6dia_Britannica/Calculating_Machines. Also this leads to many resources: https://www.johnwolff.id.au/calculators/Resources.htm. ~drummyfish }
If mechanical computer also utilizes electronic parts, it is called an electro-mechanical computer; here we'll however be mainly discussing purely mechanical computers.
Disadvantages of digital mechanical computers against electronic ones are great, they basically lose at everything except simplicity of implementation (in the desert). Mechanical computer is MUCH slower (speed will be measured in Hz), has MUCH less memory (mostly just a couple of bits or bytes), will be difficult to program (machine code only), is MUCH bigger, limited by mechanical friction (so it will also be noisy), suffers from mechanical wear etc. Analog mechanical computers are maybe a bit better in comparison, but still lose to electronics big time. But remember, less is more.
Some notable mechanical computers include e.g. the 1882 Difference Engine by Charles Babbage (aka the first programmer), Antikythera mechanism (ancient Greek astronomical computer), the famous Curta calculators (quality, powerful pocket-sized mid-20th century calculators) { These are really cool, check them out. ~drummyfish }, Enigma ciphering device (used in WWII), abacus, slide rule, Odhner Arithmometer (extremely popular Russian table calculator), Digi-Comp I (educational programmable 3 bit toy computer) or Turing Tumble { Very KISS and elegant, also check out. ~drummyfish } (another educational computer, using marbles).
Let's also take a look at how we can classify mechanical computers. Firstly they can be:
Next we may divide mechanical computers to:
And to:
Analog computers are usually special purpose. { At least I haven't ever heard about any general purpose analog computer, not even sure if that could work. ~drummyfish } Very often they just solve some specific equation, something like ballistic curves perhaps, they may perform Fourier transform, calculate areas of arbitrary shapes that can be traced by a pencil (see planimeter) etc. Especially useful are computers performing integration and solving differential equations as computing many practically encountered equations is often very hard or impossible -- mechanical machines can integrate quite well, e.g. using the famous ball and disk integrator.
As mere programmers let us focus more on digital computers now.
When building a digital computer from scratch we traditionally start by designing basic logic gates such as AND, NOT and OR -- here we implement the gates using mechanical principles rather than transistors or relays. For simple special-purpose calculators combining these logic gates together may be enough (also note we don't HAVE TO use logic gates, some mechanisms can directly perform arithmetic etc.), however for a highly programmable general purpose computer logic gates alone practically won't suffice -- in theory when we have finite memory (in real world always), we can always just use only logic gates to perform any computation, but as the memory grows, the number of logic gates we would need would grow exponentially, so we don't do this. Instead we will need to additionally implement some sequential processing, i.e. something like a CPU that performs steps according to program instructions.
Now we have to choose our model of computation and general architecture, we have possibly a number of options. Mainly we may be deciding between having a separate storage for data and program (Harvard architecture) or having the program and data in the same memory (intending for the computer to "reshape" this initial program data into the program's output). Here there are paths to explore, the most natural one is probably trying to imitate a Turing machine (many physical finite-tape Turing machines exist, look them up), probably the simplest "intuitive" computer, but we can even speculate about e.g. some kind of rewriting system imitating formal grammars, cellular automata etc -- someone actually built a simple and elegant rule 110 marble computer (look up on YT), which is Turing complete but not very practical (see Turing tarpit). So Turing machine seems to be the closest to our current idea of a computer (try to program something useful in rule 110...), it's likely the most natural way, so that might be the best first choice we try.
Turing machine has a separate memory for program and data. To build it we need two main parts: memory tape (an array of bits) and control unit (table of states and their transitions). We can potentially design these parts separately and let them communicate via some simple interface, which simplifies things. The specific details of the construction will now depend on what components we use (gears, marbles, dominoes, levers, ...)...
Here we will overview some common concepts and methods used in mechanical computers. Remember the concepts may, and often are, combined. Also note that making a mechanical computer will be a lot about mechanical engineering, so great many concepts from it will appear -- we can't recount all of them here, we'll just focus on the most important concepts connected to the computing part.
Gears (wheels with teeth) are a super simple mechanism popular in mechanical computers. Note that gears may be both digital and analog -- whether they're one or the other depends on our interpretation (if we assign importance to every arbitrary orientation or just a finite number of orientations that click the tooth into some box).
The advantages of gears are for example instant transfer of motion -- even if we have many wheels in sequence, rotating the first one instantly (practically) rotates the last one as well. Among disadvantages on the other hand may be the burden of friction (having too many gears in a row will require a lot of power for rotation and strong fixation of the gears) and also manufacturing a non-small number of good, quality gears may be more difficult than alternatives (marbles, ...).
Besides others gears/wheels can be used to:
1 1
__ ,-, ___ ,-, _______
| { o } { o } ,-, |
| '-;, ,-;' { o } |
| _|||____{ o }____;-; |
| '-;-. { o } |
|_____________ { o } _'-'__|
'-'
1
0 1
__ ,-, ___ ,-, _______
| { o } { o },-, |
| ,;-' ,-, '-'{ o } |
| _|||__{ o }_____;-; |
| '-' .-{ o } |
|_____________ { o }-'_____|
'-'
0
NXOR (equality) gate implemented with gears (counterclockwise/clockwise rotation mean 1/0); the bottom gear rotates counterclockwise only if the both input gears rotate in the same direction.
Buttons, levers, sliders and similar mechanism can be used in ways similar to gears, the difference being their motion is linear, not circular. A button can represent a bit with its up/down position, a lever can similarly represent a bit by being pointed left/right. As seen below, implementation of basic logic gates can be quite simple, which is an advantage. Disadvantages include for example, similarly to gears, vulnerability to friction -- with many logic gates in a row it will be more difficult to "press" the inputs.
___ 0 ___ 0 ___ 0 ___ 0 ___ 0
_ | _________ _ | _____ | _ _ | _____ | _
| | | | | | | | | | |
| '--o---. | | '-------' | | -----.----- |
|________ | _| |_____ | _____| |_____ | _____|
_|_ --- ---
1 0
1 1 ___ 0 1 ___ 0
_---_________ _---_____ | _ _---_____ | _
| | .-| | | | | | | | | |
| | .o' | | | | __.--'' | | _|________ |
|__'-'____ | _| |__''_ | _____| |_____ | _____|
--- --- _|_
0 0 1
NOT AND OR
Possible implementation of logic gates with buttons.
Using moving marbles (and possibly also similar rolling shapes, e.g. cylinders, disks, ...) for computation is one of the simplest and most KISS methods for mechanical computers and may therefore be considered very worthy of our attention -- the above mentioned marble rule 110 computer is a possible candidate for the most KISS Turing complete computer. But even with a more complicated marble computer it's still much easier to build a "marble maze" than to build a geared machine (even gears themselves aren't that easy to make).
Basic principle is that of a marble performing computation by going through a maze -- while a single marble can be used to evaluate some simple logic circuit, usually (see e.g. Turing Tumble) the design uses many marbles and performs sequential computation, i.e. there is typically a bucket of marbles placed on a high place from which we release one marble which (normally by relying on gravity) goes through the maze and performs one computation cycle (switches state, potentially flips a memory bit etc.) and then, at the bottom (end of its path), presses a switch to release the next marble from the top bucket. So the computation is autonomous, it consumes marbles from the top bucket and fills the bottom bucket (with few marbles available an operator may sometimes need to refill the top bucket from the bottom one). The maze is usually an angled board onto which we just place obstacles; multiple layers of boards with holes/tunnels connecting them may be employed to allow more complexity. { You can build it from lego probably. ~drummyfish }
If it's possible it may be actually simpler to use coins instead of marbles -- as they are flat, building a potentially multi-layered maze (e.g. with shifting elements) can be easier, it may be as simple as cutting the layers out of thick cardboard paper and stacking them one on another.
Also an alternative to having a top bucket full of marbles going to the bottom bucket is just having one marble and transporting it back up after each cycle -- this can be done very simply e.g. by tilting the maze the other way, so the computation is then powered by someone (or something) repeatedly tilting the board one way and back again; this is e.g. how the simple rule 110 computer works -- there the marble also does another work on its way back (it updates the barriers in the maze for itself and its neighbors for the next round of the downwards trip), so the "CPU cycle" has two phases.
NOTE: Balls, or potentially other "falling/moving objects", may be used to perform computation also in other ways than we'll describe further on -- some of the alternative approaches are for example:
These approaches may be tried as well, however further on here we will focus on the traditional "marble maze" approach in which the marbles mostly serve as a kind movement force that flips bits represented by something else (or possibly indicate answer by falling out through a specific hole).
The disadvantage here is that the computation is slow as to perform one cycle a marble has to travel some path (which may take many seconds, i.e. in the simple form you get a "CPU" with some fractional frequency, e.g. 1/5 Hz). This can potentially be improved a little, e.g. by pipelining (releaseing the next marble as soon as possible, even before the current one finishes the whole path) and parallelism (releasing multiple marbles, each one doing some part of work in parallel with others). Advantages on the other hand include mentioned simplicity of construction, visual clarity (we can often make the computer as a flat 2D board that can easily be observed, debugged etc.) and potentially good extensibility -- making the pipeline (maze) longer, e.g. to add more bits or functionality, is always possible without being limited e.g. by friction like with gears (though usually for the cost of speed).
Some things that can be done with marbles include:
if x > N), i.e. weight at which the bucket becomes heavier than a counterweight and opens some new path for the marbles.
:
# o # # # # # # #
## ## ## ## ## ## ## ##
### ### ### : ### ### ### ### ###
# \ / # # \o/ # # \ / # # \ / #
# O # # O # # oO # # O #
# #\ # # #\ # # /# # # /# #
# # # # # # # # # # : # #
# # # # # # # # # # o # #
0 1 0 1 0 1 0 1
Marble falling into a flip-flop will test its value (fall out either from the 0 or 1 hole) and also flip the bit -- next marble will fall out from the other hole. Flip-flops can be used to implement **memory.*
\: marble slide
\o
\ hole sliding plane
=============----===============VVVVVVVVVVV==== <----->
| | | | | | -''-
| b0 | b1 | b2 | b3 | b4 | { () }
| | | | | | '--' gear
bits
Above a gear is used to select which hole an incoming marble will fall into (each hole may contain e.g. a flip-flop bit shown above). This may potentially be used to e.g. implement random access memory.
O O O O
| : | | : | | : | | : |
_____| : |_ _____| : |_ ________| : | ________| : |
| |A | : /| A = 1 | |A | : /| A = 1 | |A | ./| A = 0 | |A | ./| A = 0
| |__| : /A| __| |__| : /A| | |__| ./A| |__|__| ./A|__
| /| : /| B = 1 | /| ./|"" B = 0 | /| : /| B = 0 | ./| /| B = 1
| /B| : /B| |__ /B| : /B|__ | /B| : /B| __| ./B| /B|
| |\ . | | : |\ | | |\. | | :|\ |
| |A\ .| | : |A\ | |___ |A\. |__ |___ :|A\ |__
\ | ./ \ : | / \ | : / \ : | /
\ | ./ \ : | / \ | : / \. | /
1 0 1 0 1 0 1 0
XOR computed by a marble falling through the gate (it will fall out of the 1 hole only if inputs are set to different values), inputs are implemented as shifting two parts of the gate left or right (this can be done by another falling marble) -- the parts marked with the same letter move together.
Here are some additional tips for marbles: if you want to allow a marble to be only able to go one way in the maze, you can use a mini ramp (one way it will climb it and fall over but from the other way it just behaves like a wall). You can also utilize helper marbles that can e.g. temporarily lock a moving part (obstacle) in place when computation is in progress (so that the falling marbles don't move the obstacles by bumping into them), the helper marble simply falls into some small hole where it will block horizontal movement of the part that shouldn't move, and later it can be released from this hole (this is super easy with the "changing tilt" approach mentioned above, the blocking marble simply goes up and down while in one position it's blocking, in the other it's not).
Whether the use of fluids/gases (water, air, steam, maybe even sand, ...) is still considered mechanical computing may be debatable, but let's take a look at it anyway.
Don't forget there exist many other possible components and concepts a mechanical computer can internally use -- many things we leave out above for the questionability of their practical usability can be used to in fact carry out computation, for example dominoes or slinkies. Furthermore many actually useful things exist, e.g. teethed cylinders/disks may be used to record plots of data over time or to store and deliver read/only data (e.g. the program instructions) easily, see music boxes and gramophones; punch card and paper tapes have widely been used for storing read-only data too. Sometimes deformed cylinders were used as an analog 2D look up table for some mathematical function -- imagine e.g. a device that has input x (rotating cylinder along its axis) and y (shifting it left/right); the cylinder can then at each surface point record function f(x,y) by its width which will in turn displace some stick that will mark the function value on a scale. To transfer movement strings, chains and belts may also be used. Random number generation may be implemented e.g. with Galton board. If timing is needed, pendulums can be used just like in clock. Some mechanical computers even use pretty complex parts such as mechanical arms, but these are firstly hard to make and secondly prone to breaking, so try to avoid complexity as much as possible. Some old mechanical calculators worked by requiring the user to plug a stick into some hole (e.g. number he wanted to add) and then manually trace some path -- this can work on the same principle as e.g. the marble computer, but without needing the marbles complexity and size are drastically reduced. Another ideas is a "combing" computer which is driven by its user repeatedly sliding some object through the mechanism (as if combing it) which performs the steps (sequential computation) and changes the state (which is either stored inside the computer or in the combing object).
BONUS THOUGHT: We have gotten so much used to using our current electronic digital computers for everything that sometimes we forget that at simulating actual physical reality they may still fail (or just be very overcomplicated) compared to a mechanical simulation which USES the physical reality itself; for example to make a simulation of a tsunami wave it may be more accurate to build an actual small model of a city and flood it with water than to make a computer simulation. That's why aerodynamic tunnels are still a thing. Ancient NASA flight simulators of space ships did use some electronics, but they did not use computer graphics to render the view from the ship, instead they used a screen projecting view from a tiny camera controlled by the simulator, moving inside a tiny environment, which basically achieved photorealistic graphics. Ideas like these may come in handy when designing mechanical computers as simulating reality is often what we want to do with the computer; for example if we want to model a sine function, we don't have to go through the pain of implementing binary logic and performing iterative calculation of sine approximation, we may simply use a pendulum whose swinging draws the function simply and precisely.
See microtransaction.
WIP kind of
{ There's most likely a lot of BS, math people pls send me corrections, thank u. ~drummyfish }
Numbers (from Latin numerus coming from a Greek word meaning "to distribute") are one of the most elementary mathematical objects, building stones serving most often as quantitative values (that is: telling count, size, length, order etc.) and labels, in higher math also used in much more abstract ways which have only distant relationship to traditional counting. Examples of numbers are minus one half, zero, pi or i. Numbers constitute the basis and core of mathematics and as such they sit almost at the lowest level of it, i.e. most other things such as algebra, functions and equations are built on top of numbers or require numbers to even be examined. In modern mathematics numbers themselves do not reside on the absolute bottom of the foundations though, they are themselves built on top of sets, as set theory is most commonly used as a basis of whole mathematics, however for many purposes this is just a formalism that's of practical interest only to some mathematicians (as the topic gets closer to the fringes of mathematics and at times rather pertains to philosophy) -- on the other hand numbers just cannot be avoided anywhere, by a mathematician or just a common folk. The word number may be the first that comes to our mind when we say mathematics. The area of number theory is particularly focused on examining numbers (though it's examining almost exclusively integer numbers because these seem to have the deepest pattern related e.g. to divisibility). Interest in numbers isn't exclusive to mathematics -- numbers also play an important role in culture and religion for example; some even believe in "magical" power of numbers (see numerology).
Numbers must not be mistaken for digits or figures (numerals) -- a number is a purely abstract entity while digits serve as symbols for numbers so that they can be written down. The same number may be represented with many different symbols, using one of many numeral systems (Roman numerals, tally marks, Arabic numerals of different bases etc.), for example 4 stands for a number than can also be written as IV, four, IIII, 8/2, 16:4, 2^2, 4.00 or 0b100. There are also numbers which cannot be exactly expressed with our traditional numeral systems, for some of them we have special symbols -- most prominent example is of course pi whose digits in decimal expansion form an infinite series -- and there are even numbers lacking any symbolic representation, ones not well researched yet or not important enough, only described by equations to which they are the solution. Sure enough, a number by itself isn't too interesting and probably doesn't even make sense, it's only in context, when it's placed in relationship with other numbers (by ordering them, defining operations and properties based on those operations) that patterns and useful attributes emerge.
To embark on the history a little, humans first started to use positive natural numbers (it seems as early as 30000 BC), i.e. 1, 2, 3 ..., so as to be able to trade, count enemies, days and so on -- since then they kept expanding the concept of a number with more abstraction as they encountered more complex problems. First extension was to fractions, initially reciprocals of integers (like one half, one third, ...) and then general ones. Around 6th century BC Pythagoras showed that there even exist numbers that cannot be expressed as fractions (irrational numbers, which in the beginning was a controversial discovery), expanding the set of known numbers further. A bit later (around 100 BC) negative numbers started to be used. Adoption of the number zero also took some time, with it first serving as a mere placeholder digit; true zero is said to only have been used in 7th century India. Since 16th century a highly abstract concept of complex numbers started to appear, which was later (19th century) expanded further to quaternions. With more advancement in mathematics -- e.g. with the development of set theory -- more and more concepts of new kinds of numbers appeared and still appear to this day. Nowadays we have greatly abstract numbers, ones existing in many dimensions, capable of counting and measuring infinitely large and infinitely small entities, and it seems we still haven't nearly discovered everything there is to know about numbers.
Basically anything can be encoded as a number which makes numbers a universal abstract "medium" -- this can be exploited in both mathematics and programming (which are actually the same thing). Ways of encoding information as numbers may vary, for a mathematician it is natural to see any number as a multiset of its prime factors (e.g. 12 = 2 * 2 * 3, the three numbers are inherently embedded within number 12) that may carry a message, a programmer will probably rather encode the message in binary and then interpret the 1s and 0s as a number in direct representation, i.e. he will embed the information in the digits. You can probably come up with many more ways.
But what really is a number? What makes number a number? Where is the border between numbers and other abstract objects? Essentially number is an abstract mathematical object made to model something about reality (most fundamentally the concept of counting, expressing amount) which only becomes meaninful and useful by its relationship with other similar objects -- other numbers -- that are parts of the same, usually (but not necessarily) infinitely large set. We create systems to give these numbers names because, due to there being infinitely many of them, we can't name every single one individually, and so we have e.g. the decimal system in which the name 12345 exactly identifies a specific number, but we must realize these names are ultimately not of mathematical importance -- we may call a number 1, I, 2/2, "one", "uno" or "jedna", it doesn't matter -- what's important are the relationships between numbers that create a STRUCTURE. I.e. a set of infinitely many objects is just that and nothing more; it is the relationships that allow us to operate with numbers and that create the difference between integers, real numbers or the set of colors. These relatinships are expressed by operations (functions, maps, ...) defined with the numbers: for example the comparison operation is less than (<) which takes two numbers, x and y, and always says either yes (x is smaller than y) or no, gives numbers order, it creates the number line and allows us to count and measure. Number sets usually have similar operations, typically for example addition and multiplication, and this is how we intuitively judge what numbers are: they are sets of objects that have defined operations similar to those of natural numbers (the original "cavemen numbers"). However some more "advanced" kind of numbers may have lost some of the simple operations -- for example complex numbers are not so straightforward to compare -- and so they may get more and more distant from the original natural numbers. And this is why sometimes the border between what is and what isn't a number may be blurry -- for example it can't objectively be said if infinity is a number or not, simply because number sets that include infinity lose many of the nicely defined operations, the structure of the set changes a lot. So arguing about what is a number ultimately becomes subjective, it's similar to arguing about what is and isn't a planet.
An interesting remark: someone once plotted the number of occurrences of numbers in the online encyclopedia of integer series (OEIS) and discovered a curiosity (called Sloane's Gap). There is a clear gap separating numbers into two clusters, one containing the "interesting numbers" and the other the rest ("boring numbers"). The interesting set contains primes, increments of powers of two and so on. This is partly cultural (there is a bias towards base 10 for example), but it's very interesting the gap is so clear -- one would expect there would be a spectrum of how interesting numbers are, but it seems like it's just two clusters.
Order is an important concept related to numbers, we usually want to be able to compare numbers so apart from other operations such as addition and multiplication we also define the comparison operation. However note that not every order is total, i.e. some numbers may be incomparable (consider e.g. complex numbers).
Here are some fun facts about numbers:
quaternions . imaginary line
projected : (imaginary numbers)
projected j line 2i ~+~ ~ ~ ~ ~+ 1 + 2i
k line : : ,
... :_ : , complex numbers
\___ \_ j : ,
\___ +_ i ~+~ ~ ~ ~ ~+ 1 + i
+___ \_ : ,
k \___\_ : ,
\_\_: 1 2 3 4
- - -~|~-~-~-~-~|~-~-~-~-~+~-~-|-~-~|~-~-~|~-~|~-~-~-|-~|~|~-~-~-~|~- - -
-2 -1 0: 1/2 , phi e pi real line
= i^2 : = 0.5 , ~= ~= ~= 3.14... (real numbers)
: , 1.61... 2.71...
-i ~+~ ~ ~ ~ ~+
: 1 - i
.
Number lines and some notable numbers -- the horizontal line is real line, the vertical is imaginary line that adds another dimension and reveals complex numbers. Further on we can see quaternion lines projected, hinting on the existence of yet higher dimensional numbers (which however cannot properly be displayed using mere two dimensions here).
{ Be warned the following is just me making some quick unoriginal antiresearch, I may mess something up, it's just to show the process of playing around with numbers. ~drummyfish }
Let's see how we can play around with numbers. We can for example write a C program such as this:
#include <stdio.h>
int main(void)
{
for (int i = 0; i < 50; ++i)
{
int divs = 0, // number of factors in prime factorization
divSum = 0, // sum of divs
divsUnique = 0, // unique numbers that divide the number
divUniqueSum = 0, // sum of divUniques
divMin = 0, // minimum of divs
divMax = 0, // maximum of divs
modSpreadAvg = 0,
modSpreadMin = 100,
modSpreadMax = 0,
n = i;
while (n > 1) // prime factorization
{
for (int j = 2; j <= n; ++j)
if (n % j == 0)
{
divs++;
divSum += j;
n /= j;
break;
}
}
for (int j = 2; j < i; ++j) // count unique divisors
{
int mod = i % j;
int modSpread = (200 * mod) / j - 100;
// ^ "how much" this number divides i, generalization of divisibility
modSpread *= modSpread < 0 ? -1 : 1;
if (modSpread < modSpreadMin)
modSpreadMin = modSpread;
if (modSpread > modSpreadMax)
modSpreadMax = modSpread;
modSpreadAvg += modSpread;
if (mod == 0) // divides?
{
divsUnique++;
divUniqueSum += j;
divMin = j < divMin || !divMin ? j : divMin;
divMax = j > divMax || !divMax ? j : divMin;
}
}
modSpreadAvg /= i != 0 ? i : 1;
printf("| %d | %d | %d | %d | %d | %d | %d | %d | %d | %d | %d |\n",
i,divs,divsUnique,divSum,divUniqueSum,divMin,divMax,modSpreadAvg,
modSpreadMin,modSpreadMax,((divMax - divMin) * 100) / (i != 0 ? i : 1));
}
return 0;
}
That will generate us the following table of data (for details on what the columns mean refer to the program code above):
| num | divs | uniq divs | div sum | uniq div sum | min div | max div | avg mod spread (%) | min mod spread (%d) | max mod spread (%) | div. range (%) |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 100 | 0 | 0 |
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 100 | 0 | 0 |
| 2 | 1 | 0 | 2 | 0 | 0 | 0 | 0 | 100 | 0 | 0 |
| 3 | 1 | 0 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 2 | 1 | 4 | 2 | 2 | 2 | 33 | 34 | 100 | 0 |
| 5 | 1 | 0 | 5 | 0 | 0 | 0 | 16 | 0 | 50 | 0 |
| 6 | 2 | 2 | 5 | 5 | 2 | 3 | 43 | 0 | 100 | 16 |
| 7 | 1 | 0 | 7 | 0 | 0 | 0 | 24 | 0 | 67 | 0 |
| 8 | 3 | 2 | 6 | 6 | 2 | 4 | 44 | 20 | 100 | 25 |
| 9 | 2 | 1 | 6 | 3 | 3 | 3 | 36 | 0 | 100 | 0 |
| 10 | 2 | 2 | 7 | 7 | 2 | 5 | 41 | 0 | 100 | 30 |
| 11 | 1 | 0 | 11 | 0 | 0 | 0 | 34 | 0 | 80 | 0 |
| 12 | 3 | 4 | 7 | 15 | 2 | 6 | 53 | 0 | 100 | 33 |
| 13 | 1 | 0 | 13 | 0 | 0 | 0 | 35 | 0 | 84 | 0 |
| 14 | 2 | 2 | 9 | 9 | 2 | 7 | 43 | 0 | 100 | 35 |
| 15 | 2 | 2 | 8 | 8 | 3 | 5 | 44 | 0 | 100 | 13 |
| 16 | 4 | 3 | 8 | 14 | 2 | 8 | 50 | 10 | 100 | 37 |
| 17 | 1 | 0 | 17 | 0 | 0 | 0 | 38 | 0 | 88 | 0 |
| 18 | 3 | 4 | 8 | 20 | 2 | 9 | 47 | 0 | 100 | 38 |
| 19 | 1 | 0 | 19 | 0 | 0 | 0 | 42 | 0 | 89 | 0 |
| 20 | 3 | 4 | 9 | 21 | 2 | 10 | 51 | 0 | 100 | 40 |
| 21 | 2 | 2 | 10 | 10 | 3 | 7 | 45 | 0 | 100 | 19 |
| 22 | 2 | 2 | 13 | 13 | 2 | 11 | 44 | 0 | 100 | 40 |
| 23 | 1 | 0 | 23 | 0 | 0 | 0 | 42 | 0 | 91 | 0 |
| 24 | 4 | 6 | 9 | 35 | 2 | 12 | 55 | 0 | 100 | 41 |
| 25 | 2 | 1 | 10 | 5 | 5 | 5 | 45 | 0 | 100 | 0 |
| 26 | 2 | 2 | 15 | 15 | 2 | 13 | 46 | 0 | 100 | 42 |
| 27 | 3 | 2 | 9 | 12 | 3 | 9 | 44 | 0 | 100 | 22 |
| 28 | 3 | 4 | 11 | 27 | 2 | 14 | 49 | 0 | 100 | 42 |
| 29 | 1 | 0 | 29 | 0 | 0 | 0 | 46 | 0 | 93 | 0 |
| 30 | 3 | 6 | 10 | 41 | 2 | 15 | 52 | 0 | 100 | 43 |
| 31 | 1 | 0 | 31 | 0 | 0 | 0 | 45 | 0 | 94 | 0 |
| 32 | 5 | 4 | 10 | 30 | 2 | 16 | 48 | 4 | 100 | 43 |
| 33 | 2 | 2 | 14 | 14 | 3 | 11 | 45 | 0 | 100 | 24 |
| 34 | 2 | 2 | 19 | 19 | 2 | 17 | 48 | 0 | 100 | 44 |
| 35 | 2 | 2 | 12 | 12 | 5 | 7 | 48 | 0 | 100 | 5 |
| 36 | 4 | 7 | 10 | 54 | 2 | 18 | 54 | 0 | 100 | 44 |
| 37 | 1 | 0 | 37 | 0 | 0 | 0 | 45 | 0 | 95 | 0 |
| 38 | 2 | 2 | 21 | 21 | 2 | 19 | 45 | 0 | 100 | 44 |
| 39 | 2 | 2 | 16 | 16 | 3 | 13 | 47 | 0 | 100 | 25 |
| 40 | 4 | 6 | 11 | 49 | 2 | 20 | 52 | 0 | 100 | 45 |
| 41 | 1 | 0 | 41 | 0 | 0 | 0 | 48 | 0 | 95 | 0 |
| 42 | 3 | 6 | 12 | 53 | 2 | 21 | 51 | 0 | 100 | 45 |
| 43 | 1 | 0 | 43 | 0 | 0 | 0 | 47 | 0 | 96 | 0 |
| 44 | 3 | 4 | 15 | 39 | 2 | 22 | 50 | 0 | 100 | 45 |
| 45 | 3 | 4 | 11 | 32 | 3 | 15 | 48 | 0 | 100 | 26 |
| 46 | 2 | 2 | 25 | 25 | 2 | 23 | 47 | 0 | 100 | 45 |
| 47 | 1 | 0 | 47 | 0 | 0 | 0 | 47 | 0 | 96 | 0 |
| 48 | 5 | 8 | 11 | 75 | 2 | 24 | 54 | 0 | 100 | 45 |
| 49 | 2 | 1 | 14 | 7 | 7 | 7 | 49 | 0 | 100 | 0 |
Now we may start looking into the data. Check out for example that prime numbers have max mod spread ("mod spread" being a sort of percentage of "how much" one number divides another) lower than 100% -- naturally because by definition no number perfectly divides a prime (except for the excluded divisors 1 and the number itself). For instance 19 is "almost" divisible by 10, but not quite, hence we see 89%. So here we can generalize the concept of prime number and call some primes "better" if they have lower max mod spread (they are "further" from being divisible by something). Now let's notice we can make a nice tree of the numbers by assigning each number as its parent its greatest divisor:
1
|
.----.-----------.------------.-----'--.-----.---.--.--.--.--.--.--.--.--.
| | | | | | | | | | | | | | |
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 <--- primes
| | | | | | | | |
| .-'--. .----+----. .---.-'-.--. .-'-. .-'-. | | |
| | | | | | | | | | | | | | | | |
4 6 9 10 15 25 14 21 35 49 22 33 26 39 34 38 46
| | | | | | | | |
| | .-'-. | .-'-. | | | |
| | | | | | | | | | |
8 12 18 27 20 30 45 50 28 42 44
| | | |
16 24 36 40
| |
32 48
Here patterns start to show, for example the level one of the tree are all prime numbers. Also in this tree we can nicely find the greatest common divisor of two numbers as their closest common ancestor. Also if we go from low numbers to high numbers (1, 2, 3, ...) we see we go kind of in a zig-zag direction around the bottom-right diagonal -- what if we make a program that plots this path? Will we see something interesting? We could use this tree to encode numbers in an alternative way too, by indicating path to the number, for example 45 = {2,1,1}. Would this be good for anything? Would such a representation facilitate some operations? You can just keep diving down rabbit holes like this.
There are countless different types of numbers, in mathematics we classify them into sets (and if we additionally consider operations with numbers too, we also sort them into algebras and structures such as groups, fields or rings). Although we can talk about finite sets of numbers perfectly well (e.g. modulo arithmetic, Boolean algebra etc.), we are often examining and using infinite sets (curiously some of these infinite sets can still be considered "bigger" than other infinite sets, e.g. by certain logic there is more real numbers than rational numbers, i.e. "fractions"). Some of these sets are subsets of others, some overlap and so forth. Here are some notable number sets (note that a list can potentially not capture all relationships between the sets):
One of the most interesting and mysterious number sets are the prime numbers, in fact many number theorists dedicate their whole careers solely to them. Primes are the kind of thing that's defined very simply but give rise to a whole universe of mysteries and whys, there are patterns that seem impossible to describe, conjectures that look impossible to prove and so on. Another similar type of numbers are the perfect numbers.
Of course there are countless other number sets, especially those induced by various number sequences and functions of which there are whole encyclopedias. Another possible division is e.g. to cardinal and ordinal numbers: ordinal numbers tell the order while cardinals say the size (cardinality) of a set -- when dealing with finite sets the distinction doesn't really have to be made, within natural numbers the order of a number is equal to the size of a set of all numbers up to that number, but with infinite sets this starts to matter -- for example we couldn't tell the size of the set of natural numbers by ordinals as there is no last natural number, but we can assign the set a cardinal number (aleph zero) -- this gives rise to new kind of numbers.
Worthy of mentioning is also linear algebra which treats vectors and matrices like elementary algebra treats numbers -- though vectors and matrices aren't usually seen as numbers, they may be seen as an extension of the concept.
Numbers are awesome, just ask any number theorist (or watch a numberphile video for that matter). Normal people perceive numbers just as boring, soulless quantities but the opposite is true for that who studies them with love -- the world of numbers is without a doubt staggeringly beautiful, their study runs to depths without end, possibly as far as humans can ever hope to get a glimpse of the mechanisms behind the curtains of our Universe, and oftentimes once you pay a closer attention to a seemingly innocently looking detail, you reveal a breathtaking pattern and discover the art of nature. Each number has its own unique set of properties which give it a kind of "personality", different sets of numbers create species and "teams" of numbers. Numbers are intertwined in intricate ways, there are literally infinitely many patterns that are all related in weird ways -- normies think that mathematicians know basically everything about numbers, but in higher math it's the exact opposite, most things about number sequences are mysterious and mathematicians don't even have any clue about why they're so, many things are probably even unknowable. Numbers are also self referencing which leads to new and new patterns appearing without end -- for example prime numbers are interesting numbers, but you may start counting them and a number that counts numbers is itself a number, you are getting new numbers just by looking at other numbers. The world of numbers is like a whole universe you can explore just in your head, anywhere you go, it's almost like the best, most free video game of all time, embedded right in this Universe, in logic itself. Numbers are like animals, some are small, some big, some are hardly visible, trying to hide, some can't be overlooked -- they inhabit various areas and interact with each other, just exploring this can make you quite happy. { Pokemon-like game with numbers when? ~drummyfish }
There is a famous encyclopedia of integer sequences at https://oeis.org/, made by number theorists -- it's quite minimalist, now also free licensed (used to be proprietary, they seem to enjoy license hopping). At the moment it contains more than 370000 sequences; by browsing it you can get a glimpse of how deep the study of numbers goes. These people are also somewhat funny, they give numbers entertaining names like happy numbers (adding its squared digits eventually gives 1), polite numbers, friendly numbers, cake numbers, lucky numbers or weird numbers.
Some numbers cannot be computed, i.e. there exist noncomputable numbers. This follows from the existence of noncomputable functions (such as that representing the halting problem). For example let's say we have a real number x, written in binary as 0. d0 d1 d2 d3 ..., where dn is nth digit (1 or 0) after the radix point. We can define the number so that dn is 1 if and only if a Turing machine represented by number n halts. Number x is noncomputable because to compute the digits to any arbitrary precision would require being able to solve the unsolvable halting problem.
All natural numbers are interesting: there is a fun proof by contradiction of this. Suppose there exists a set of uninteresting numbers which is a subset of natural numbers; then the smallest of these numbers is interesting by being the smallest uninteresting number -- we've arrived at contradiction, therefore a set of uninteresting numbers cannot exist.
TODO: what is the best number? maybe top 10? would 10 be in top 10? what's the first number that's in top itself?
While mathematicians work mostly with infinite number sets and all kinds of "weird" hypothetical numbers like hyperreals and transcendentals, programmers still typically deal with "normal" numbers pertaining to practical applications, and have to limit themselves to finite number sets because, of course, computers have limited memory and can only store limited number of numeric values -- computers typically work with modulo arithmetic with some high power of two, e.g. 2^32 or 2^64, which is a good enough approximation of an infinite number set. Mathematicians are as precise with numbers as possible as they're interested in structures and patterns that numbers form, programmers just want to use numbers to solve problems, so they mostly use approximations where they can -- for example programmers normally approximate real numbers with floating point numbers that are really just a subset of rational numbers. This isn't really a problem though, computers can comfortably work with numbers large and precise enough for solving any practical problem -- a slight annoyance is that one has to be careful about such things as underflows and overflows (i.e. a value wrapping around from lowest to highest value and vice versa), limited and sometimes non-uniform precision resulting in error accumulation, unlinearization of linear systems and so on. Programmers also don't care about strictly respecting some properties that certain number sets must mathematically have, for example integers along with addition are mathematically a group, however signed integers in two's complement aren't a group because the lowest value doesn't have an inverse element (e.g. on 8 bits the lowest value is -128 and highest 127, the lowest value is missing its partner). Programmers also allow "special" values to be parts of their number sets, especially e.g. with the common IEEE floating point types we see values like plus/minus infinity, negative zero or NaN ("not a number") which also break some mathematical properties and creates situations like having a number that says it's not a number, but again this really doesn't play much of a role in practical problems. Numbers in computers are represented in binary and programmers themselves often prefer to write numbers in binary, hexadecimal or octal representation -- they also often meet powers of two rather than powers of ten or primes or other similar limits (for example the data type limits are typically limited by some power of two). There also comes up the question of specific number encoding, for example direct representation, sign-magnitude, two's complement, endianness and so on. Famously programmers start counting from 0 (they go as far as using the term "zeroth") while mathematicians rather tend to start at 1. Just as mathematicians have different sets of numbers, programmers have an analogy in numeric data types -- a data type defines a set of values and operations that can be performed with them. The following are some of the common data types and representations of numbers in computers:
However some programming languages, such as Lisp, sometimes treat numbers in very abstract, more mathematical ways (for the price of some performance loss and added complexity) such as exactly handling rational numbers with arbitrary precision, distinguishing between exact and inexact numbers etc. The question of number representation is an important one. Though most commonly we meet direct representation, two's complement, floating and fixed point representations, many more alternatives exist that may facilitate storing or manipulation of the values we are to work with. Among these alternatives are for example fractions (numerator and denominator), p-adics, RNS (number stored as its modulo against a fixed set of relatively prime numbers), BCD (binary coded decimal digits), factorial base number system and many others.
See also https://mrob.com/pub/math/numbers.html.
Here is a table of some numbers and "number like objects" worthy of mention, mostly relevant in math and programming but also some famous ones from physics and popular culture (note: the order is roughly from lower numbers to higher ones, however not all of these numbers can be compared easily or at all, so the ordering isn't strictly correct; notes: & means base 8, b3 means base 3).
| number | value | equal to, AKA | notes |
|---|---|---|---|
| not a number (NaN, undefined, ...) | none | 1/0, 0^0, tan(pi/2) | error value |
| minus infinity | not always considered a number, smallest possible value | ||
| -9223372036854776000 | -1 * 2^64 / 2 | minimum two's complement signed 64 bit number | |
| -2147483648 | -1 * 2^32 / 2 | minimum two's complement signed 32 bit number | |
| minus thirty two thousand seven ... | -32768 | -1 * 2^16 / 2 | minimum two's complement signed 16 bit number |
| minus one hundred twenty eight | -128 | -1 * 2^7 | minimum value of signed byte (two's complement) |
| minus/negative one | -1 | i^2, j^2, k^2 | |
| minus one twelfth | -0.08333... | -1/12 | infamous, by some methods the result of 1 + 2 + 3 + ... |
| -3.402823... * 10^38 | smallest number storable in IEEE-754 32 bit float | ||
| -1.797693... * 10^308 | smallest number storable in IEEE-754 64 bit float | ||
| "negative zero" | "-0" | 0 | non-mathematical, sometimes used in programming |
| zero (none, nil) | 0 | "-0", e^(i * pi) + 1, lim x->inf 1/x | "nothing", additive identity |
| epsilon | 1/omega | infinitesimal, "infinitely small" non-zero | |
| 4.940656... * 10^-324 | smallest pos. number storable in IEEE-754 64 bit float | ||
| 1.401298... * 10^-45 | smallest pos. number storable in IEEE-754 32 bit float | ||
| 1.616255... * 10^-35 | Planck length in meters, smallest "length" in Universe | ||
| one hundredth | 0.01 | 1/100, 1%, 0b0.000000101000111101... | |
| 0.065988... | 1/(e^e) | lowest x such that x^x^x^... is bounded (by 1/e) | |
| 0.071111111111111... | 0x0.123456789abcdef101... | base 16 Champernowne constant | |
| one tenth | 0.1 | 1/10, 10%, 0b0.000110011001100111... | |
| 0.123456789101112... | 0b0.000111111001101011... | base 10 Champernowne constant, normal number | |
| one eight | 0.125 | 1/8, 2^-3, 0b0.001, 0x0.2 | |
| 0.163264812105216... | &0.1234567101112131415... | base 8 Champernowne constant | |
| 0.207879... | i^i, e^(-pi/2) | ||
| one fourth | 0.25 | 25%, 2^-2, 1 - 2 + 3 - ..., 0b0.01, 0x0.4 | |
| one over pi | 0.318309... | 1/pi, pi^-1 | |
| one third | 0.333333... | 3^-1, ...1313132 (5adic), 1 - 2 + 4 - ... | |
| one over e | 0.367879... | 1/e | optimal solution to the "secretary problem" |
| Thue-Morse constant | 0.412454... | 0b0.011010011001011010... | keep appending negated binary strings (start with 0) |
| prime constant | 0.414682... | 0b0.011010100010100010... | binary number that encodes primes in fractional digits |
| one half | 0.5 | 50%, 2^-1, 0b0.1, 0x0.8 | |
| Euler's constant (gamma) | 0.577215... | 1 + 1/2 + 1/3 + 1/n ... - log(n) | some kinda deep and important constant O_O |
| 0.598958... | base3(0.121011122021221001...) | base 3 Champernowne constant | |
| one over square root of two | 0.707106... | 1/sqrt(2), sin(pi/4), cos(pi/4), 2^(-1/2) | |
| 0.862240124493837... | 0b0.110111001011101111... | base 2 Champernowne constant | |
| one | 1 | 2^0, 0!,, 0.999..., sqrt(1), I, 0b1, cos(0) | NOT a prime, unit, multiplicative identity |
| 1.261859... | ln(4)/ln(3) | Hausdorff dimension of Koch snowflake fractal | |
| square root of two | 1.414213... | sqrt(2), 2^(1/2), 0b1.0110101 | irrational, diagonal of unit square, important in geom. |
| ten over seven | 1.428571... | 10/7 | common approximation of sqrt(2) |
| supergolden ratio | 1.465571... | solve(x^3 - x^2 - 1 = 0) | similar to golden ratio, bit more difficult to compute |
| 1.584962... | log(3)/log(2) | Hausdorff dimensions of Sierpinski triangle fractal | |
| phi (golden ratio) | 1.618033... | (1 + sqrt(5)) / 2, solve(x^2 - x - 1 = 0) | irrational, visually pleasant ratio, divine proportion |
| square root of three | 1.732050... | sqrt(3), 3^(1/2), 0b1.1011101 | irrational |
| square root of pi | 1.772453... | sqrt(pi) | |
| two (couple, pair) | 2 | 2^1, 2!,, 2!!!,, 0b000010, II, 0b10 | (only even) prime, base of binary system |
| silver ratio | 2.414213... | 1 + sqrt(2), solve(x^2 - 2 * x - 1 = 0) | similar to golden ratio |
| nineteen over seven | 2.714285... | 19/7 | common approximation of e |
| e (Euler's number) | 2.718281... | 0b10.1011011 | base of natural logarithm |
| three | 3 | 2^2 - 1, III, Ob11, 2^1.584... | prime, max. number on 2 bits, regular plane tilings |
| pi | 3.141592... | 2 * asin(1), 0b11.0010010 | circle circumference to its diameter, irrational |
| twenty two over seven | 3.142857... | 22/7 | common approximation of pi |
| square root of ten | 3.162277... | sqrt(10) | approximation of pi |
| four | 4 | 2^2, 0b000100, IV, 0b100 | first composite number, min. needed to color planar graph |
| Feigenbaum constant | 4.669201... | related to chaotic systems | |
| five | 5 | 3^2 - 2^2, V, 0b101, fib(5) | (twin, triplet, super) prime, num. of Plat. solids, Fib. |
| six (half dozen) | 6 | 3!,, 1 * 2 * 3, 1 + 2 + 3, VI, 0b110 | highly composite number, 1st perfect number, semiprime |
| tau | 6.283185... | 2 * pi, 360 degrees | radians in full circle, defined mostly for convenience |
| thrembo | ??? | the hidden number | |
| seven | 7 | 2^3 - 1, VII, &7, 0b111 | (twin) prime, days in week, max. unsigned n. with 3 bits |
| eight | 8 | 2^3, 0b001000, VIII, &10, 0b1000, fib(6) | base of octal system, 7th Fibonacci number |
| 8.539734... | pi * e | ||
| nine | 9 | 3^2, 1^3 + 2^3, sqrt(81), IX, 0b1001 | semiprime |
| pi squared | 9.869604... | pi^2 | |
| ten | 10 | 10^1, 1 + 2 + 3 + 4, X, 0b1010, 2^3.321... | your IQ? :D base of our decimal system, semiprime |
| eleven | 11 | 0xb, b3(102), &13, 0b1011, XI | palindromic twin&super(4) prime |
| twelve (dozen) | 12 | 2 * 2 * 3, 0xc, 0b1100, XII | highly composite number, Platonic solid (dod.) face count |
| thirteen (long or devil's dozen) | 13 | fib(7), trib(7), 0xd, 0b1101, XIII | prime considered unlucky (in west and China), Fib. num. |
| fourteen | 14 | &112, 0b1110, 0xe, XIV | semiprime |
| fifteen | 15 | 2^4 - 1, 0b1111, 0xf, 1 + 2 + 3 + 4 + 5 | maximum unsigned number storable with 4 bits |
| sixteen | 16 | 2^4, 4^2, 2^2^2, 0b010000, &20, 0x10, XVI | base of hexadecimal system |
| seventeen | 17 | 0b10001, &21, 0x11, XVII | twin&sexy&super(2) prime, binary palindrome |
| eighteen | 18 | 0b10010, &22, 0x12, XVIII | |
| nineteen | 19 | 0b10011, &23, 0x13, XIX | twin&sexy prime |
| twenty | 20 | 0b10100, &24, 0x14, XX, score | largest number of faces for a Platonic solid (icos.) |
| twenty one | 21 | 0b10101, 0x15, BB(3), fib(8), 0x15, XXI | maximum number of 1s produced by 3 state Turing Machine |
| twenty three | 23 | 0b10111, &27, 0x17, XXIII | sexy prime, obsession to many people (23 enigma) |
| twenty four | 24 | 2 * 2 * 2 * 3, 4!,, trib(8), 0x18, XXIV | highly composite number, possible ways to order 4 objects |
| twenty five | 25 | 5^2, sqrt(625), 0x19, XXV | |
| twenty seven | 27 | 3^3, 0b11011, 0x1b, &33, 0x1b, XXVII | palindrome in base 2 and 8 |
| twenty eight | 28 | 0b11100, 0x1c, XXVIII | 2nd perfect number |
| twenty nine | 29 | 0b11101, &1002, 0x1d, XXIX | twin&sexy prime |
| thirty | 30 | 0b11110, &1010, 0x1e, XXX | |
| thirty one | 31 | 2^5 - 1, 0b11111, &37, 0x1f, XXXI | max. unsigned number storable with 5 bits, Mersenne prime |
| thirty two | 32 | 2^5, 0b100000, &40, 0x20, XXXII | number of possible values storable with 5 bits |
| thirty three | 33 | 1! + 2! + 3! + 4!,, XXXIII | |
| thirty four | 34 | fib(9), 0x22, XXXIV | Fibonacci number |
| thirty six | 36 | 2 * 2 * 3 * 3, XXXVI | highly composite number |
| thirty seven | 37 | 0b100101, 0x25, XXXVII | most commonly picked 1 to 100 "random", permutable prime |
| forty | 40 | 0b101000, 0x28, XL | |
| forty one | 41 | 0b101001, 0x29, XLI | twin&sexy prime |
| forty two | 42 | XLII | cringe number, answer to some stuff, unlucky in Japan |
| forty three | 43 | 0b101011, 0x2b, XLIII | twin&sexy prime, 4th Sylvester's number |
| forty four | 44 | trib(9), 0b101100, 0x2c, XLIV | Tribonacci number |
| forty seven | 47 | 0b101111, 0x2f, XLVII | sexy prime |
| forty eight | 48 | 2^5 + 2^4, 2 * 2 * 2 * 2 * 3, XLVIII, 0x30 | highly composite number |
| forty nine | 49 | 7^2, XLIX | |
| fifty | 50 | 0x32, L | |
| fifty three | 53 | 0b110101, 0x35, LIII | sexy prime |
| fifty five | 55 | fib(10), 1 + 2 + ... + 10, LV | sum of numbers up to 10, 11th Fibonacci number |
| fifty nine | 59 | 0b111011, 0x3b, LIX | twin&sexy&super(3) prime |
| sixty | 60 | 2^2 * 3 * 5, 0x3c, LX, threescore | (super.) highly composite number, used in time measuring |
| sixty one | 61 | 0x3d, LXI | twin&sexy prime |
| sixty three | 63 | 2^6 - 1, 0b111111, &77, 0x3f, LXIII | maximum unsigned number storable with 6 bits |
| sixty four | 64 | 2^6, 0b1000000, &100, 0x40, LXIV | number of squares on a chess board |
| sixty seven | 67 | 0x43, LXVII | sexy&super(2) prime |
| sixty nine | 69 | 0x45, LXIX | sexual position |
| seventy | 70 | 0x46, LXX | |
| seventy one | 71 | 0x47, LXXI | twin prime |
| seventy three | 73 | 0b1001001, 0x49, LXXIII | twin&sexy prime, binary palindrome |
| seventy five | 75 | 0x5b, LXXV | |
| seventy nine | 79 | 0x4f, LXXIX | sexy prime |
| eighty | 80 | 0x50, LXXX | |
| eighty one | 81 | trib(10), 3^4, 9^2, XXCI | Tribonacci number |
| eighty three | 83 | LXXXIII | sexy&super(2) prime |
| eighty eight | 88 | 0x58, LXXXVIII | number of essentially different cellular automata |
| eighty nine | 89 | fib(11), 0x59, LXXXIX | Fibonacci number, sexy prime |
| ninety | 90 | 0x5a, XC | |
| ninety six | 96 | 2^5 + 2^6, 5! - 4!,, 0x60, XCVI | alternative sexual position |
| ninety seven | 97 | XCVII | sexy prime |
| ninety nine | 99 | 10^2 - 1, 0b1100011 | palindrome in base 2 and 10 |
| one hundred | 100 | 10^2, 0x64, C, 2^6.643... | |
| one hundred seven | 107 | BB(4), CVII | maximum number of 1s produced by 4 state Turing machine |
| one hundred eight | 108 | 0x6c, CVIII, 1 * 2^2 * 3^3, hyperfact(3) | |
| one hundred twenty | 120 | 2^3 * 3 * 5, 5!,, C(10,3), CXX | possible ways to order 5 objects, highly composite |
| one hundred twenty one | 121 | 11^2, CXXI | palindromic, semiprime |
| one hundred twenty five | 125 | 5^3, CXXV | |
| one hundred twenty seven | 127 | 2^7 - 1, 0b01111111, &177, 0x7f, CXXVII | maximum value of signed byte, 4th Mersenne&super(6) prime |
| one hundred twenty eight | 128 | 2^7, 0x80, &200, CXXVIII, 10^2.107... | number of values storable with 7 bits |
| one hundred forty four (gross) | 144 | 12^2, fib(12), CXLIV | 13th Fibonacci number, 12 dozen |
| one hundred fifty | 150 | 0x96, CL | |
| one hundred sixty eight | 168 | 24 * 7, CLXVIII | hours in week |
| one hundred eighty | 180 | 2^2 * 3^2 * 5, 0xb4, CLXXX | highly composite, degrees in half of full angle |
| two hundred | 200 | 0xc8, CC | |
| twi hundred forty | 240 | 0xf0, CCXL | highly composite |
| two hundred forty three | 243 | 3^5, 0xf3, CCXLIII | |
| two hundred fifty five | 255 | 2^8 - 1, 0b11111111, &377, 0xff, CCLV | maximum value of unsigned byte, hex palindrome |
| two hundred fifty six | 256 | 2^8, 4^4, 16^2, 0x100, ((2^2)^2)^2, CCLVI | number of values that can be stored in one byte |
| two hundred eighty eight | 288 | 0x120, CCLXXXVIII, 1^1 + 2^2 + 3^3 + 4^4 | |
| three hundred | 300 | 0x12c, CCC | |
| three hundred forty three | 343 | 7^3, CCCXLIII | palindrome |
| three hundred sixty | 360 | 2 * 2 * 2 * 3 * 3 * 5, CCCLX | highly composite number, degrees in full circle |
| three hundred sixty five | 365 | 0x16d, CCCLXV | days in a year, binary palindrome |
| four hundred | 400 | 0x190, CD | |
| four hundred twenty | 420 | 0x1a4, CDXX | stoner shit (they smoke it at 4:20), divisible by 1 to 7 |
| four hundred ninety six | 496 | 0x1f0, CDXCVI | 3rd perfect number |
| five hundred | 500 | 0x1f4, D | |
| five hundred eleven | 511 | 2^9 - 1, DXI | largest number storable with 9 bits |
| five hundred twelve | 512 | 2^9, 2^(3^2), DXII | number of values storable with 9 bits |
| six hundred twenty five | 625 | 25^2, 5^4, DCXXV | |
| six hundred and sixty six | 666 | 0x29a, DCLXVI | number of the beast, palindromic |
| seven hundred nine | 709 | 0x2c5, DCCIX | first super prime of order 7 |
| seven hundred twenty | 720 | 2^4 * 3^2 * 5, 6!,, 3!!!,, DCCXX | possible ways to order 6 objects, highly composite |
| seven hundred twenty nine | 729 | 3^6, (3^2)^3, DCCXXIX | |
| seven hundred fifty | 750 | 0x2ee, DCCL | |
| shitload | ??? | clusterfuck, a lot | expressed a bigger quantity |
| nine hundred ninety nine | 999 | 10^3 - 1, 0x3e7, CVXCIX | palindromic |
| one thousand (grand) | 1000 | 1K, 10^3, M, 0x3e8, 2^9.965... | |
| one thousand twenty three | 1023 | 2^10 - 1, &1777, 0x3ff, MXXIII | largest number storable with 10 bits |
| one thousand twenty four | 1024 | 2^10, 4^5, &2000, 0x400, MXXIV, 10^3.01... | number of values storable with 10 bits |
| one thousand three hundred ... | 1337 | 0x539, MCCCXXXVII | leet number |
| one thousand six hundred eighty | 1680 | 0x690, MDCLXXX | highly composite, often used as horizontal resolution |
| one thousand seven hundred ... | 1729 | 0x6c1, MDCCXXIX | Ramanujan number, taxican number, part of math lore |
| one thousand eight hundred ... | 1807 | 0x70f, MDCCCVII | 5th Sylvester's number |
| one thousand eight hundred ... | 1836.152673... | proton to electron mass ratio, unitless, uncertainty err. | |
| two thousand | 2000 | 0x7d0, MM | |
| two thousand forty eight | 2048 | 2^11, 0x800, MMXLVIII | number of values storable with 11 bits |
| two thousand one hundred eighty seven | 2187 | 3^7, 0x88b, MMCLXXXVII | |
| two thousand four hundred one | 2401 | 7^4, MMCDI | |
| three thousand one hundred ... | 3125 | 5^5, MMMCXXV | |
| three thousand nine hundred ... | 3999 | MMMCMXCIX | largest number that can be written with Roman numerals |
| four thousand ninety five | 4095 | 2^12 - 1, &7777, 0xfff | maximum unsigned integer storable with 12 bits |
| four thousand ninety six | 4096 | 2^12, 2^(3^4), &10000, 0x1000 | number of values storable with 12 bits |
| five thousand | 5000 | 0x1388 | |
| five thousand forty | 5040 | 7!,, 1 * 2 * ... * 7 | possible ways to order 7 objects |
| five thousand fifty | 5050 | 1 + 2 + ... + 100 | sum of numbers up to 100 |
| five thousand three hundred eight one | 5381 | 0x1505 | sexy, first super prime of order 8 |
| six thousand five hundred sixty one | 6561 | 3^8, 3^(2^3) | |
| six thousand seven hundred sixty five | 6765 | fib(20), 0x1a6d | Fibonacci number |
| seven thousand seven hundred ... | 7734 | 0x1e36 | on a calculator say "hello" (upside down) |
| eight thousand one hundred ... | 8128 | 0x1fc0 | 4th perfect number |
| eight thousand one hundred ninety one | 8191 | 0x1fff, 2^13 - 1 | 5th Mersenne prime |
| eight thousand one hundred ninety two | 8192 | 0x2000, 2^13 | number of values storable with 13 bits |
| ten thousand (myriad) | 10000 | 10^4, 100^2, 2^13.287... | |
| fifteen thousand six hundred ... | 15625 | 5^6, 0x3d09 | |
| sixteen thousand three hundred ... | 16384 | 2^14, 0x4000 | number of values storable with 14 bits |
| sixteen thousand eight hundred ... | 16807 | 7^5, 0x41a7 | |
| nineteen thousand six hundred ... | 19683 | 3^9, 3^(3^3), 0x4ce3 | |
| twenty seven thousand six hundred ... | 27648 | 1 * 2^2 * 3^3 * 4^4, hyperfact(4) | |
| thirty two thousand seven hundred ... | 32767 | 2^16 / 2 - 1, 0x7fff | maximum two's complement signed 16 bit number |
| thirty two thousand seven hundred ... | 32768 | 2^15, 0x8000 | number of values storable with 15 bits |
| forty thousand three hundred twenty | 40320 | 8!,, 1 * 2 * ... * 8, 0x9d80 | possible ways to order 8 objects |
| ... (enough lol) | 52711 | twin prime, first super prime of order 9 | |
| 59049 | 3^10, 0xe6a9 | ||
| 65504 | largest number storable in IEEE-754 16 bit float | ||
| 65535 | 2^16 - 1, &177777, 0xffff | maximum unsigned number storable with 16 bits | |
| 65536 | 2^16, 256^2, &200000, 0x10000, 2^(2^(2^2)) | number of values storable with 16 bits | |
| 72078 | number of possible chess positions after 4 half moves | ||
| 80085 | looks like BOOBS | ||
| 86400 | 60 * 60 * 24 | seconds in a day | |
| hundred thousand | 100000 | 10^5, 2^16.609... | |
| 131071 | 2^17 - 1 | 6th Mersenne prime | |
| 197281 | number of possible chess games after 4 half moves | ||
| 307200 | 640 * 480 | number of pixels in god's resolution | |
| 362880 | 9!,, 1 * 2 * ... * 9 | possible ways to order 9 objects | |
| 500500 | 1 + 2 + ... + 1000 | sum of numbers up to 1000 | |
| 648391 | first super prime of order 10 | ||
| one million | 1000000 | 1M, 10^6, 0xf4240, 2^19.931... | |
| 3263443 | twin prime, 6th Sylvester's number | ||
| 3628800 | 10!,, 1 * 2 * ... * 10 | possible ways to order 10 objects | |
| 9737333 | first super prime of order 11 | ||
| 16777216 | 2^24, 16^6, 0xffffff | number of distinct 24 bit values, no. of RGB24 colors | |
| 16777217 | 2^24 + 1, 0x1000000 | min. pos. int. unstorable in 32b float (prec. falls < 1) | |
| 43046721 | 3^16 | ||
| 47176870 | BB(5) | maximum number of 1s produced by 5 state Turing machine | |
| 31556926 | seconds in a year | ||
| 33550336 | 5th perfect number | ||
| 39916800 | 11!,, 1 * 2 * ... * 11 | possible ways to order 11 objects | |
| 86400000 | 1 * 2^2 * 3^3 * 4^4 * 5^5, hyperfact(5) | ||
| 479001600 | 12!,, 1 * 2 * ... * 12 | possible ways to order 12 objects | |
| one billion | 1000000000 | 1B, 10^9, milliard, 0x3b9aca00, 2^29.89... | |
| 2147483647 | 2^32 / 2 - 1 | maximum two's complement signed 32 bit number, Mer. prime | |
| 3735928559 | 0xdeadbeef | one of famous hexadeciaml constants, spells out DEADBEEF | |
| 4294967295 | 2^32 - 1, 0xffffffff | maximum unsigned number storable with 32 bits | |
| 4294967296 | 2^32, ((((2^2)^2)^2)^2)^2, 0x100000000 | number of values storable with 32 bits | |
| 6227020800 | 13!,, 1 * 2 * ... * 13 | possible ways to order 13 objects | |
| 8589869056 | 0x1ffff0000 | 6th perfect number | |
| 9876543210 | 0x24cb016ea | all decimal digits from highest to lowest | |
| 16889859363 | number of possible go games after 4 half moves | ||
| 87178291200 | 14!,, 1 * 2 * ... * 14 | possible ways to order 14 objects | |
| hundred billion | 100000000000 | 10^11 | approximate number or stars in Milky Way galaxy |
| 137438691328 | 0x1ffffc0000 | 7th perfect number | |
| 500000500000 | 1 + 2 + ... + 1000000 | sum of numbers up to 1000000 | |
| one trillion | 1000000000000 | 10^12, billion (LS) | |
| 1307674368000 | 15! | possible ways to order 15 objects | |
| 4031078400000 | 2^2 * 3^3 * 4^4 * 5^5 * 6^6, hyperfact(6) | ||
| 10650056950807 | 7th Sylvester's number | ||
| 20922789888000 | 16! | possible ways to order 16 objects | |
| thirty trillion | 30000000000000 | approximate number of cells in human body | |
| 355687428096000 | 17! | possible ways to order 17 objects | |
| bazillion | ??? | used to just express a very large value | |
| quadrillion | 1000000000000000 | 10^15 | |
| 6402373705728000 | 18! | possible ways to order 18 objects | |
| 9007199254740992 | precision of IEEE double falls below 1 after this num. | ||
| 121645100408832000 | 19! | possible ways to order 19 objects | |
| quintillion | 1000000000000000000 | 10^18 | |
| 2305843008139952128 | 0x1fffffffc0000000 | 8th perfect number | |
| 2432902008176640000 | 20! | possible ways to order 20 objects | |
| 9223372036854776000 | 2^64 / 2 - 1 | maximum two's complement signed 64 bit number | |
| 18364758544493064000 | 0xfedcba9876543210 | all hexadecimal digits from highest to lowest | |
| 18446744073709551615 | 2^64 - 1, 0xffffffffffffffff | maximum unsigned number storable with 64 bits | |
| 18446744073709551616 | 2^64 | number of values storable with 64 bits | |
| 43252003274489856000 | number of possible Rubik's cube configurations | ||
| 2015099950053364471960 | number of possible chess games after 15 half moves | ||
| 6670903752021072936960 | possible valid filled sudoku grids | ||
| 1.000000... * 10^30 | 1000000000000066600000000000001 | Belphegor's prime, evil (666, 13 zeroes), palindromic | |
| 1.267650... * 10^30 | 2^100 | number of values storable with 100 bits | |
| 2.658455... * 10^36 | 9th perfect number | ||
| 3.402823... * 10^38 | (2 - 2^(-23)) * 2^127 | largest number storable in IEEE-754 32 bit float | |
| 3.402823... * 10^38 | 2^128 | number of values storable with 128 bits | |
| 1.915619... * 10^53 | 10th perfect number | ||
| 1.157920... * 10^77 | 2^256 | number of values storable with 256 bits | |
| bazillionplex | ??????? | 10^bazillion | one followed by bazillion zeros |
| 10^80 | approx. number of atoms in observable universe | ||
| googol | 10^100 | often used big number | |
| Shannon number | 10^120 | estimated number of possible games in chess | |
| asankhyeya | 10^140 | religious number, often used in Buddhism | |
| 1.340780... * 10^154 | 2^512 | number of values storable with 512 bits | |
| 9.332621... * 10^157 | 100! | possible ways to order 100 objects | |
| 4.65... * 10^185 | approx. number of Planck volumes in observable universe | ||
| 1.797693... * 10^308 | largest number storable in IEEE-754 64 bit float | ||
| 1.797693... * 10^308 | 2^1024 | number of values storable with 1024 bits | |
| 3.231700... * 10^616 | 2^2048 | number of values storable with 2048 bits | |
| 2.601218... * 10^1746 | 3!!!!! | ||
| 4.023872... * 10^2567 | 1000! | possibe ways to order 1000 objects | |
| googolplex | 10^(10^100) | 10^googol | another large number, number of genders in 21st century |
| 10^^10 | 9PT10, 10^10^10^10^10^10^10^10^10^10 | ||
| Graham's number | g64 | extremely, unimaginably large number, > googolplex | |
| TREE(3) | unknown | yet even larger number, > Graham's number | |
| (absolute) infinity | lim x->0 1/x, 1 + 1 + 1 + ... | not always considered a number, largest possible value | |
| aleph zero | beth zero, cardinality(N) | infinite cardinal number, "size" of the set of nat. num. | |
| THE EDGE POINT OF NUMBERS | ??? | ??? | largest informal number of fictional googology wiki |
| 🫖 | ??? | ??? | largest number on fictional googology wiki, > abs. inf. |
| i (imaginary unit) | j * k | part of complex numbers and quaternions | |
| j | k * i | one of quaternion units | |
| k | i * j | one of quaternion units | |
| 1/sqrt(2) + i/sqrt(2) | sqrt(i) | one of the square roots of imaginary unit | |
| -1/sqrt(2) - i/sqrt(2) | sqrt(i) | one of the square roots of imaginary unit |
"Micro$oft <3 open $ource"
Open source (OS, also Open $ource) is a capitalist movement, in recent years degraded to a mere brand, forked from the free software movement; it is advocating at least partial "openness", i.e. strategic sharing of design parts with the public and allowing unpaid volunteer contributors from the public to take part in software and hardware development; though technically and legally the definition of open source is mostly identical to free (as in freedom) software, in practice and in spirit it couldn't be more different as for abandoning the goal of freedom and ethics in favor of business (to which ethics is an obstacle), due to which we see open source as inherently evil and recommend following the free software way instead. Richard Stallman, the founder of free software, distances himself from the open source movement. Fascist organizations such as Microsoft and Google, on the other hand, embrace open source (while restraining from using the term free software) and slowly shape it towards their goals. Open source is a short for "yes, it will abuse you, but at least you can read its source code." The term FOSS is sometimes used to refer to both free software and open source without expressing any preference.
Open source unfortunately (but unsurprisingly) became absolutely prevalent over free software as it better serves capitalism and abuse of people, and its followers are more and more hostile towards the free software movement. This is very dangerous, ethics and focus on actual user freedom is replaced by shallow legal definitions that can be bypassed, e.g. by capitalist software and bloat monopoly. In a way open source is capitalism reshaping free software so as to weaken it and eventually make its principles of freedom ineffective. Open source tries to shift the goal posts: more and more it offers only an illusion of some kind of ethics and/or freedom, it pushes towards mere partial openness ("open source" for proprietary platforms), towards high complexity, inclusion of unethical business-centered features (autoupdates, DRM, ...), high interdependency, difficulty of utilizing the rights granted by the license, exclusion of developers with "incorrect" political opinions or bad brand image etc. In practice open source has become something akin to a mere brand which is stick to a piece of software to give users with little insight a feeling they're buying into something good -- this is called openwashing. This claim is greatly supported by the fact that corporations such as Microsoft and Google widely embrace open source ("Microsoft <3 open source", the infamous GitHub acquisition etc.).
"Open source" as a term and brand arose by the group of capitalists, such as Linus Torvalds and Eric. S. Raymond (author of The Cathedral And Bazaar, a guide of how to exploit programmers to maximize profit), who were at the time part of the free software movement but at the same time felt great sadness that they couldn't make enough money on something that's focused on ethical goals. At the beginning of 1998 some of these businessmen held a meeting in Palo Alto with the goal of shifting the goal posts where one of them -- allegedly Christine Peterson (a woman) -- suggested the term "open source" (other alternatives were e.g. "sourceware") which then passed by vote. Consequently the next month the Open Source Initiative (OSI), a new propaganda organization, was formed, with Raymond as its president. Sadly most of the self proclaimed "anticapitalist rebels" among zoomers aren't even aware of this recent history and happily follow this purely capitalist movement, use the terms open source, embrace and use anything with the open source sticker on it, use GitHub etc., thinking they're "opposing something". This is exactly what Open Source wanted to achieve, a false sense of rebellion that will actually make most programmers do their bidding.
"Free and Open Source: it is completely **FREE OF COST and ALMOST ALL of its components are open source."* --GNU/Linux Mint's website already marketing partially proprietary system as "open source" and purposefully misusing the word "free" to mean "gratis" (February 2024)
{ Mint also hilariously markets itself as KISS lol. My friend suggested they only implemented the "stupid" part of it :-) ~drummyfish }
One great difference of open source with respect to free software is that open source doesn't mind proprietary dependencies and only "partially open" projects (see also open core): Windows only programs or games in proprietary engines such as Unity are happily called open source -- this would be impossible in the context of free software because as Richard Stallman says software can only be free if it is free as a whole, it takes a single proprietary line of code to allow abuse of the user. The "open source" communities nowadays absolutely don't care a bit about freedom or ethics (the majority of open source supporting zoomers most likely don't even know there was ever any connection), many "open source" proponents even react aggressively to bringing the idea of ethics up. "Open source" communities use locked, abusive proprietary platforms such as Discord, Google cloud documents and Micro$oft's GitHub to create software and collaborate -- users without Discord and/or GitHub account often aren't even offered a way to contribute, report bugs or ask for support. There are plenty of "open source" projects that are just meant to be part of a mostly proprietary environment, for example the Mangos implementation of World of Warcraft server, which of course has to be used with the proprietary WoW client and with proprietary server assets, which gives Blizzard (the owner of WoW) complete legal control over any server running on such an "open source" server (such servers always only rely on Blizzard temporarily TOLERATING their small noncommercial communities, despite Blizzard having taken some of them down with legal action) -- calling such a project "free software" in this context would just sound laughable, so they rather call it "open source", i.e. "no, there is no freedom, but the source is technically open". Lately you will even see more and more people just calling any software/project "open" as long as some part of its source code is available for viewing on GitHub, no matter the license or any other considerations (see e.g. "open"geofiction etc.).
The open source definition is maintained by the Open Source Initiative (OSI) -- they define what exactly classifies as open source and which licenses are compatible with it. These licenses are mostly the same as those approved by the FSF (even though not 100%). The open source definition is a bit more complex than that of free software, in a nutshell it goes along the lines:
Besides this main legal definition open source is also a cult that comes with its own rituals and ways of thinking, again, mostly harmful ones like embracing update culture which allows the overlords to push something to people and then keep reshaping it silently with "updates" as they're using it (see e.g. the infamous xz incident in Linux).
Open source also colossally fails on other fronts, e.g. for example by not accepting CC0 as a valid license and not accepting esoteric programming languages (because they're "obfuscated"). All in all, avoid open source, support free software.
Pi (normally written with a Greek alphabet symbol with Unicode value U+03C0) is one of the most important and famous numbers, equal to approximately 3.14, most popularly defined as the ratio of a circle's circumference to its diameter (but also definable in other ways). It is one of the most fundamental mathematical constants of our universe and appears extremely commonly in mathematics, nature and, of course, programming. When written down in traditional decimal system, its digits go on and on without end and show no repetition or simple pattern, appearing "random" and chaotic -- as of 2021 pi has been evaluated by computers to 62831853071796 digits, although approximate values have been known from very early times (e.g. the value (16/9)^2 ~= 3.16 has been known as early as around 1800 BC). In significance and properties pi is similar to another famous number: e. Pi day is celebrated on March 14.
{ Very nice site about pi: http://www.pi314.net. ~drummyfish }
Pi is a real transcendental number, i.e. simply put it cannot be defined by a "simple" equation (it is not a root of any polynomial equation). As a transcendental number it is also an irrational number, i.e. it cannot be written as an integer fraction. Mathematicians nowadays define pi via the period of the exponential function rather than geometry of circles. If we stick to circles, it is interesting that in non-Euclidean geometry the value of "pi" could be measured to different values (if we draw a circle on an equator of a ball, its circumference is just twice its diameter, i.e. "pi" would be measured to be just 2, reveling the curvature of space).
Pi to 100 decimal digits is:
`3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679...
Pi to 100 binary fractional digits is:
`11.001001000011111101101010100010001000010110100011000010001101001100010011000110011000101000101110000...
Among the first 50 billion digits the most common one is 8, then 4, 2, 7, 0, 5, 9, 1, 6 and 3. Pi squared equals approximately 9.8696044010, the square root of pi is approximately 1.7724538509.
Some weirdos memorize digits of pi for fun and competition, the official world record as of 2022 is 70030 memorized digits, however Akira Haraguchi allegedly holds an unofficial record of 100000 digits (made in 2006). Some people make mnemonics for remembering the digits of pi (this is known as PiPhilology), for example "Now I fuck a pussy screaming in orgasm" is a sentence that helps remember the first 8 digits (number of letters in each word encodes the digit).
PI IS NOT INFINITE. Soyence popularizators and nubs often say shit like "OH LOOK pi is so special because it infiniiiiiite". Pi is completely finite with an exact value that's not even greater than 4, what's infinite is just its expansion in decimal (or similar) numeral system, however this is nothing special, even numbers such as 1/3 have infinite decimal expansion -- yes, pi is more interesting because its decimal digits are non-repeating and appear chaotic, but that's nothing special either, there are infinitely many numbers with the same properties and mysteries in this sense (most famously the number e but besides it an infinity of other no-name numbers). The fact we get an infinitely many digits in expansion of pi is given by the fact that we're simply using a system of writing numbers that is made to handle integers and simple fractions -- once we try to write an unusual number with our system, our algorithm simply ends up stuck in an infinite loop. We can create systems of writing numbers in which pi has a finite expansion (e.g. base pi), in fact we can already write pi with a single symbol: pi. So yes, pi digits are interesting, but they are NOT what makes pi special among other numbers.
Additionally contrary to what's sometimes claimed it is also unproven (though believed to be true), whether pi in its digits contains all possible finite strings -- note that the fact that the series of digits is infinite doesn't alone guarantee this (as e.g. the infinite series 010011000111... doesn't contain any possible combinations of 1s and 0s either). This would hold if pi was normal -- then pi's digits would contain e.g. every book that will ever be written (see also Library Of Babel). But again, there are many other such numbers.
What makes pi special then? Well, mostly its significance as one of the most fundamental constants that seems to appear extremely commonly in math and nature, it seems to stand very close to the root of description of our universe -- not only does pi show that circles are embedded everywhere in nature, even in very abstract ways, but we find it in Euler's identity, one of the most important equations, it is related to complex exponential and so to Fourier transform, waves, oscillation, trigonometry (sin, cos, ...) and angles (radians use pi), it even starts appearing in number theory, e.g. the probability of two numbers being relative primes is 6/(pi^2), and so on.
FUN SIDENOTE: One of the fucking weirdest places where pi shows up, as highlighted by a video of the math madman 3Blue1Brown, is in the following experiment. Assume absolutely ideal conditions (frictionless motion, perfect preservation of energy, perfectly elastic collisions, ...). If you have a solid block of mass 1 kg at some distance from a wall and from the other side you send towards it another solid block of mass 10^N kg and then you count the number of collisions that happen, you'll get the first N + 1 digits of pi. What the actual fuck.
Evaluating many digits of pi is mathematically interesting, programs for computing pi are sometimes used as CPU benchmarks. There are programs that can search for a position of arbitrary string encoded in pi's digits. However in practical computations we can easily get away with pi approximated to just a few decimal digits, you will NEVER need more than 20 decimal digits, not even for space flights (NASA said they use 15 places).
One way to judge the quality of pi approximation can be to take the number of pi digits it accurately represents versus how many digits there are in the approximation formula -- this says kind of the approximation's compression ratio. But other factors may be important too, e.g. simplicity of evaluation, functions used etc.
Also remember, you can measure pi in real life by many methods: you can draw a big circle, measure its radius and circumference and then make the division, you can also manually perform the Monte Carlo algorithm (see below) by drawing a circle and then throwing objects around, counting how many fall inside and outside (just watch out to do it correctly, for example you must have the fall spot probability as random as possible, not biased in any way), or you can similarly make a square from wood, then cut out its inscribed circle, weight both parts and compute pi (with the same formula as for Monte Carlo).
{ I tried this -- I took a pizza box, cut out four squares, then used a pencil on string to draw quarter circles on each, cut them and weighted both groups. All the circle parts weighted 61 grams, the rest weighted 16 grams, this gives me a nice estimate value of pi of about 3.16. ~drummyfish }
An ugly engineering approximation that's actually usable sometimes (e.g. for fast rough estimates with integer-only hardware) is just (something like this was infamously almost made the legal value of pi by the so called Indiana bill in 1897)
`pi ~= 3
In very old times pi was estimated by Brahmagupta to be
`pi ~= sqrt(10) = 3.16227766...
A simple fractional approximation (correct to 6 decimal fractional digits, by Tsu Chung Chih) is
`pi ~= 355/113 = 3.14159292...
Such a fraction can again be used even without floating point -- let's say we want to multiply number 123 by pi, then we can use the above fraction and compute 355/113 * 123 = (355 * 123) / 113.
Srinivasa Ramanujan made a great number of pi approximations, e.g. an improvement of the previous to (14 correct digits):
`pi ~= 355/113 * (1 - 0.0003/3533)
Similarly Plouffe, e.g. (30 correct digits):
`pi ~= ln(262537412640768744) / sqrt(163)
Leibnitz formula for pi is an infinite series that converges to the value of pi, however it converges very slowly { Quickly checked, after adding million terms it was accurate to 5 decimal fractional places. ~drummyfish }. It goes as
`pi = 4 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + ...
Nilakantha series converges much more quickly { After adding only 1000 terms the result was correct to 9 decimal fractional places for me. ~drummyfish }. It goes as
`pi = 3 + 4/(2 * 3 * 4) + 4/(4 * 5 * 6) + 4/(6 * 7 * 8) + ...
A simple algorithm for computing approximate pi value can be based on approach used in further history: approximating a circle with many-sided regular polygon and then computing the ratio of its circumference to diameter -- as a diameter here we can take the average of the "big" and "small" diameter of the polygon. For example if we use a simple square as the polygon, we get pi ~= 3.31 -- this is not very accurate but we'll get a much higher accuracy as we increase the number of sides of the polygon. In 15th century pi was computed to 16 decimal digits with this method. Using inscribed and circumscribed polygons we can use this to get lower and upper bounds on the value of pi.
Another simple approach is monte carlo estimation of the area of a unit circle -- by generating random (or even regularly spaced) 2D points (samples) with coordinates in the range from -1 to 1 and seeing what portion of them falls inside the circle we can estimate the value of pi as pi = 4 * x/N where x is the number of points that fall in the circle and N the total number of generated points.
Digits of pi also emerge when trying to measure some distances inside Mandelbrot set (see David Bolle, 1991) -- this can perhaps also be exploited.
Spigot algorithm can be used for computing digits of pi one by one, without floating point. Bailey-Borwein-Plouffe formula (discovered in 1995) interestingly allows computing Nth hexadecimal (or binary) digit of pi, WITHOUT having to compute previous digits (and in a time faster than such computation would take). In 2022 Plouffe discovered a similar formula for computing Nth decimal digit.
The following is a C implementation of the Spigot algorithm for calculating digits of pi one by one that doesn't need floating point or special arbitrary length data types, adapted from the original 1995 paper. It works on the principle of converting pi to the decimal base from a special mixed radix base 1/3, 2/5, 3/7, 4/9, ... in which pi is expressed just as 2.22222... { For copyright clarity, this is NOT a web copy paste, it's been written by me according to the paper. ~drummyfish }
#include <stdio.h>
#define DIGITS 1000
#define ARRAY_LEN ((10 * DIGITS) / 3)
unsigned int pi[ARRAY_LEN];
void writeDigit(unsigned int digit)
{
putchar('0' + digit);
}
int main(void)
{
unsigned int carry, digit = 0, queue = 0;
for (unsigned int i = 0; i < ARRAY_LEN; ++i)
pi[i] = 2; // initially pi in this base is just 2s
for (unsigned int i = 0; i < DIGITS; ++i)
{
carry = 0;
for (int j = ARRAY_LEN - 1; j >= 0; --j)
{ // convert to base 10 and multiply by 10 (shift one to left)
unsigned int divisor = (j + 1) * 2 - 1; // mixed radix denom.
pi[j] = 10 * pi[j] + (j + 1) * carry;
carry = pi[j] / divisor;
pi[j] %= divisor;
}
pi[0] = carry % 10;
carry /= 10;
switch (carry)
{ // latter digits may influence earlier digits, hence these buffers
case 9: // remember consecutive 9s
queue++;
break;
case 10: // ..X 99999.. becomes ..X+1 00000...
writeDigit(digit + 1);
for (unsigned int k = 1; k <= queue; ++k)
writeDigit(0);
queue = 0;
digit = 0;
break;
default: // normal digit, just print
if (i != 0) // skip the first 0
writeDigit(digit);
if (i == 1) // write the decimal point after 1st digit
putchar('.');
digit = carry;
for (unsigned int k = 1; k <= queue; ++k)
writeDigit(9);
queue = 0;
break;
}
}
writeDigit(digit); // write the last one
return 0;
}
Procedural generation (procgen, also PCG -- procedural content generation -- not to be confused with procedural programming, but see also RNG) refers to creation of data (and in rarer cases maybe even programs), such as art assets in games or test data for data processing software, by using algorithms, mathematical formulas and randomness rather than creating them manually or measuring them in the real world (e.g. by taking photographs, 3D scans etc.). This can be used for example for automatic generation of textures, texts, music, game levels or 3D models but also practically anything else, e.g. test databases, animations or even computer programs. Such data are also called synthetic. Procedural art currently doesn't reach artistic qualities of a skilled human artist, but it can be good enough or even necessary (e.g. for creating extremely large worlds), it may be preferred e.g. for its extreme save of storage memory, it can help add detail to human work, be a good filler, a substitute, an addition to or a basis for manually created art. Procedural generation has many advantages such as saving space (instead of large data we only store small code of the algorithm that generates it), saving artist's time (once we have an algorithm we can generate a lot data extremely quickly), parameterization (we can tweak parameters of the algorithm to control the result or create animation, often in real-time), increasing resolution practically to infinity or extending data to more dimensions (e.g. 3D textures). It's also fun for the programmer. Procedural generation can also be used as a helper and guidance, e.g. an artist may use a procedurally generated game level as a starting point and fine tune it manually, or vice versa, procedural algorithm may create a level by algorithmically assembling manually created building blocks.
Procedural generation basically means randomly generating things with some added cleverness, i.e. some kind of algorithm and parameter tuning. Randomly generating something isn't that hard, provided we have a good (pseudo)random number generator -- for example to generate random loot in an RPG game may be as simple as generating a single random number representing the item ID -- this isn't yet procedural generation. The process becomes procedural generation if we throw in more rules and cleverness: for example once we start randomly generating cities so that their layout makes some sense (i.e. there are no unreachable streets, buildings in middle of the roads etc.). While doing this it's important to retain in mind all the rules of handling randomness with computers, i.e. we don't really want to employ true randomness but rather deterministic pseudorandomness! The whole thing, no matter how big, will be generated just from a single seed number. The same seed must always generate the same thing. And so on and so forth.
xc,.....,:cco,,,';,;o:':l:kkkxoooxkkc:',..'.xocxxx ,,:lccoxxkkkx;',;:;lck ,;;, xcl;::,':xkkkxxoccl;,' kx:,:'.'.'':;'...ooXkxl:xXXxocccccokkxkx;;',l:cXoX :,::lcoxxkkXKKK:'',;lx :,,;.xc;:'',KKKXkkxxocl::,, kcc;:':','.......::XkXckkxkxocccooxkkXkXXxco:clkkX lll:,:lcoxxxkXKXc'',;o :;;; ol,''lXKXkkxxocl:,:lll xx;;:'lo;.........;ckxxXkxxoooccooxkkkkkkoXkoxokxk ccoll:,;loccoxXxoo;.,l,:::;,l:.;ooxXxoccol;,:;locc x:'.:,;xl'.......',;;xXkkxxxxoooooxkkkkkXxXkkxkkkk xxxocll::loooxXxocoo:..,;:,'.,xocoxXxoool::llcoxoo o:,:xXXkk:.........:'Kkxxxkkkkxxxkxkkkkxkokcl',XxX xkXxxxccl;;cxkXxolccoo, ,: ,ooccloxXkxc;;lccxxkXkx :''cokkkX,........','0kxoxkxkkkkkkkxkkkkkXo:..,ll; kkXkxxcoxcl;cxKxo;llccol',loccll;oxKxcllcxocxxkKkk ..;'';l,'........lXkXXxxxxkkxxkkkkkkx;;occ,.....'. ,o0XkkoxxxxoccXkx;;;llccooccll;;;xkXccoxxoxokkX0x, ..'''.........,',0kxoooxxxoocoxkkkkx:,:',:,....... ':;XKKkkkkkXKXXxloccllccooccllccoloXXKXkkkkkKKK;:. ..:c::.....':olc'Kxocooxxxoocoxkkkx;'.'c:;'....... :,'.:kooccllllclkkK;::::;;;:::;KXXccllllccock;'',, kkKXkoc;cXxKKXXxcXkxoxkkkkkkkxokxxk;..;':'.....,lc ;;:,'.loccll;;;kko:xoc..''..cok:okk;;;llccol'',::; xxxxxxxkkkXkkkkkxkxoooxxkkkcl:;xkk;.........';kKkk cccl;:,'loccll;l:;xkKccllllccKXxl:l;lllcoc'':;lccc ooxxxkokkkkkkxxxkxxooxxkc::';:,,cl'','.....c0kkooc ''''.':, 'oocclc;:,:cKWMkxMWMc:'::cllcox,.':,.'''' cooooxk;'xkxxkkkxkkxoxoc;kXc'',,,'',,......cXxcccc ::l;;:;:;'.;oocol:.'oX0oK0o0Xx, :locool'';;::;:l:: oxkkxk;.'oXkxkkkxkxkkx',;okxccx;';c:.'.....xXxxooo :lc:;;;::''lcoool:.'okKo0Mo0Xx,.:loooo;'';:;;;,ll, ;,:,'''.'lkkxxxooxxok''',:oXkxkkkko'...;;,:,cccxcl ''''',:, 'oocclc;:',c0WWxxMW0c:'::cllcoo' ,::''''' ..........;;;XkxxXc,;.....oKxoocook,'.:::;'l:,c'.. cccl;:,'loccll;l:;xkKccccccccXXxl,l;llccol'':;lccc .............lxlc:o:'.....'Xkxooookx:,'...::kXo'.. ;;:,'.;occll;;;kxo:koo......coX:oxk;;;llcco;.',:;; ............',::;Xkol......cXkoocoxkl,''xx:,kX,... :,'.:kccccllllllXkKl::::;;::::;KkXccllllcccok:.',, ..........,cKl,;,xxl.....,,kkkxooxookXXXkkkk;,::.. ',;kKXxkkkkkXXXolocc;lcccoccllccolcXkXkkkkkxXKX;,. '........'kXxkk;,;,,..,'l',cXkxxooxxooxkkkkco,:l,x 'o0XkkoxxxkxocXkk;;;llccooccll;;;xkXooxxxxxokkX0o' ,,''''...:xkxkk,;;',':,;c,'ookkkxxxxocooxxxkX:c;:: kkKkxxcooollcxKko;llccoc,'loccll;oxKxcllcxocxxkKkk xkcll,'..'xXxko;',l;:'.cxl,:okkkkkxoooooooooxkoxcl xkXkxxccl;;cxkXxollcoo, ,, ,oocllcxXkxc;;lccxxkXkx oxxl;.'..,cXkkc:'olxc.'l;':ckXkkkkxooooooooxkocccl xxxoccl::lcooxXxocco;..:l;:..,xccoxXxoool::llcoxxo ':'',,l;clolxllooxxxX:...',0xxxoooxxkkkkkxxol..... ccoll:,;loccooXxool',;::::;:;,.;ooxXooccol;,:llocc .','''clcl:',;;ccxokkc....oKxoooooxkkkoc:;,....... lll:,:lcoxxxkXKXo,.,;o :;;: o;,''cXKXkxxxocl:,:lll '......',,,:oxxXooo;,'..'lMkokkxxxkx:.,..''llocl:. ;:::;coxxkkXXK0:'',;lx :,,;.xc;,'':0KXXkkxxocl::,: :'......';l;o;'';,:''.'ox:,cxkXkkkkoc,......:lxxx; ',:;lcooxkkkkl',:,;lcx ,l;:.xcl;:::';xkkkxoocl;:,'
Some procedural textures.
As neural AI approaches human level of creativity, we may see computers actually replacing many artists in near future, however it is debatable whether AI generated content should be called procedural generation as AI models are quite different from the traditional hand-made procedural algorithms -- AI art is still seen as a separate approach than traditional procedural generation. For this we'll only be considering the traditional approach from now on.
Minecraft (or, for the real chads, Minetest) is a popular, relatively recent example of a game completely based on procedural generation, in which the world is wholly procedurally generated, which allows it to have near-infinite worlds -- size of such a world is in practice limited only by ranges of data types rather than available storage memory. Roguelikes also heavily utilize procgen. However this is nothing new, for example the old game called Daggerfall was known for its extremely vast procedurally generated world, and even much older games used this approach (perhaps more so that there was so little storage memory available). Some amount of procedural generation can be seen probably in most mainstream games, e.g. clouds, vegetation or NPCs are often made procedurally.
For its extreme potential for saving space procedural generation is popular a lot in demoscene where programmers try to create as small programs as possible. German programmers made a full fledged 3D shooter called .kkrieger that fits into just 96 kB! It was thanks to heavy use of procedural generation for the whole game content. Bytebeat is a simple method of generating procedural "8bit" music, it is used e.g. in Anarch. Procedural generation is generally popular in indie game dev thanks to offering a way of generating huge amounts of content quickly and without having to pay artists.
We may see procgen as being similar to compression algorithms: we have large data and are looking for an algorithm that's much smaller while being able to reproduce the data (but here we normally go the other way around, we start with the algorithm and see what data it produces rather than searching for an algorithm that produces given data). John Carmack himself called procgen "basically a shitty compression".
Using fractals (e.g. those in a form of L-system) is a popular technique in procgen because fractals basically perfectly fit the definition perfectly: a fractal is defined by a simple equation or a set of a few rules that yield an infinitely complex shape. Nature is also full of fractals such as clouds, mountain or trees, so fractals look organic.
There are also other techniques such as wave function collapse which is used especially in tile map generation. Here we basically have some constraints set (such as which tiles can be neighbors) and then consider the initial map a superposition of all possible maps that satisfy these constraints -- we then set a random tile (chosen from those with lowest entropy, i.e. fewest possible options) to a random specific value and propagate the consequences of it to other tiles causing a cascading effect of collapsing the whole map into one of the possible solutions.
A good example to think of is generating procedural textures -- similar techniques may also be used to create procedural terrain heightmaps etc. This is generally done by first generating a basis image or multiple images, e.g. with noise functions such as Perlin noise (it gives us a grayscale image that looks a bit like clouds). We then further process this base image(s) and combine the results in various ways, for example we may use different transformations, modulations, blending, adding color using color ramps etc. The whole texture is therefore described by a graph in which nodes represent the operations we apply; this can literally be done visually in software like Blender (see its shader editor). The nice thing is that we can now for example generalize the texture to 3 dimensions, i.e. not only have a flat image, but have a whole volume of a texture that can extremely easily be mapped to 3D objects simply by intersecting it with their surfaces which will yield a completely smooth texturing without any seams; this is quite often used along with raytracing -- we can texture an object by simply taking the coordinates of the ray hit as the 3D texture coordinates, it's that simple. Or we can animate a 2D texture by doing a moving cross section of 3D texture. We can also write the algorithm so that the generated texture has no seams if repeated side-by-side (by using modular "wrap-around" coordinates). We can also generate the texture at any arbitrary resolution as we have a continuous mathematical description of it; we may perform an infinite zoom into it if we want. As if that's not enough, we can also generate almost infinitely many slightly different versions of this texture by simply changing the seed of pseudorandom generator we use.
We use procedural generation mainly in two ways:
Indeed we may also do something "in between", e.g. generate procedural assets into temporary files or RAM caches at run time and depending on the situation, for example when purely realtime generation of such assets would be too slow.
The following are some techniques and concepts often used in procedural generation:
Here are some cool ASCII renderings of procedurally generated pictures:
....,':..:.,.c;:,,.,'M0....',:c.,c,'o:xcx.',.'l:,;'.:., ...''.'..:.,.;,''x0Xoc;:::::;lo.':o,c;;c..:l.,''..,..., .',......',;':',oKxl:'.........',;cX:o0k.'l':''......,. .;........''';l.:x;,Kkocl;::::;lcxX':cX;'o',,........., .:.'........'l;.Kc:Xol:,'.......'':;ck0c'.l',.'.......' l.'.''.....'.:..XlXo;,'..xooccooxkXKMW.'.:,:..,'..',.,, ...,;,....,.:,.olcxl:'.cl;::,,,::;;coklxolcl..',';'::,' '':c:.;'.:'l,..oxo:;,.l:,''......'',:.,...'',;;c..c:o;c x.''.l':k'.l,..oc;;;,;:''.....xxkXK0xKxxxxxk.''''',:.,' xlc00lkl,.xc;.Xxl::,,:,'...;;;llccol;l;;lllxxxxxkkK;ck' c:kX:x:klWKxl.KXc;,,'.'..,,,,,,::;,,,,:,:,cooxkK,:;cxKW oo':o,kl,Kxl:'MKk;;,'....''..''''''''','''',,:;coX0,;oX c.,o,Xc,.kc;,.Kkoc;:'...............''',,:;c..',;ck.';o .:.:.o:'.xl:'..xc;:,''..................'',:lo..,:ck.:c ;.l'.l,..o;,'..ol;,''..............'',;...',:lx..,lx.,c 'x:.xl,..o;:'...l:,''...... ......'',:l...':;o..,lx.:x .c,.xl,..xl:,'...;,''..............'',;lo..',;o..,l.'l. .c:.kc:,..ol:,''..................'',:;cx..':lx.':o.:.: 0o;'.kc;,'..c;:,,'''...............':;cokK.,;ck.,cX,o,. 'Xo;,0Xoc;:,,'''','''''''''..''....',;;kKM':lxK,lk,o:'o :WKxc;:,Kkxooc,:,:,,,,;::,,,,,,..'.',,;cXK.lxKWlk:x:Xk: :'kc;Kkkxxxxxlll;;l;loccll;;;...',:,,::lxX.;cx.,lkl00cl :',.:,'''''.kxxxxxKx0KXkxx.....'':;,;;;co..,l.'k:'l.''. oc;o:c..c;;,''...,.:,''......'',:l.,;:oxo..,l':.';.:c:' ,',::';','..lcloxlkoc;;::,,,::;lc.':lxclo.,:.,....,;,.. ',,.,'..',..:,:.'.WMKXkxooccoox..',;oXlX..:.'.....''.'. ;'.......'.,'l.'c0kc;:''.......',:loX:cK.;l'........'.: ,,.........,,'o';Xc:'Xxcl;::::;lcokK,;x:.l;'''........; ..,......'':'l'.k0o:Xc;,'.........':lxKo,':';,'......,' .,...,..'',.l:..c;;c,o:'.ol;:::::;coX0x'',;.,.:..'.''.. 0KXXkkxxooooccccccoxo;:,'...',:;lcoxXWKXkkxxxooooccccco XMXxxooocccclllllllllcl:,'...',:;lcokK0Xxxoooccclllllll kK0Xxocccllll;;;;;;;;;;l;,'..'',:;lcxk0Kkooccclll;;;;;; xXMKkocllll;;;;:::::::::;;,'..',:;lcoxXMXxoclll;;;;;::: okKKkxclll;;;;:::::::,:::;:'..'',:;loxXMXkocll;;;;::::: okK0kxcll;;;;:::::::,,,::::,...',:;lcxX0Kkocll;;;;::::: xk0Kkoclll;;;;:::::::::::;:'..',,:;coxXWXxoclll;;;;:::: xXWXxocclll;;;;;;:::::;;l:,...',:;lcokK0kxocclll;;;;;:: k0Kkxooccclllll;;;;;;lll:,'..',:;lcoxXMXkooocccllll;;;; K0Xkxxxoooccccclllccoc;:,'..',,:;lcxk0Kkkxxooocccccllll W0KXXkkxxxoooooooxkol;,''..',,:;lcokKM0KXXkkxxxooooooox K0MM0KXXXkkkkkXK0kcl:,''..'',:;lcokXXK0W00KXXXkkkkkXKMx kXXK00WMM00MW0k0xcl:,''..'',:;lcoxxxkkXKK0MWM000MMKkXol xkkkXXXKKKXXxkKxcl;:,'...',,:;lccooxxxkkXXXKKKKXkxXXoc; xxxkkkkkkkxoxMkol;:,''..'',:;llcccoooxxxkkkkkkkxckKxcl; oxxxxkkkkxolk0xcl;:,'...'',:;llcccooooxxxxkkkxxooKXxcl; oxxxkkkkkxxck0kol;:,'...'',:;llcccoooxxxxkkkkkxocXKxcl; xxkkkXXXXXkxcKXoc;:,''...',::;lccoooxxxkkkXXXXXkxxWkol; kkXXKK000000XkKkol;:,'...'',:;lcooxxxkkXXKK00000KXoMxcl XKK0W00KKXXXXK0XXol;:,'. .',::;lcxkkXXK0MM0KKKXXXKKWXkc 0W0KKXkkkxxxxxxxkKxc;:,'...',:;;coxXK0M0KXXkkkxxxxxxxkM 0KXkkxxxooooccccccoxol:,'...',:;lcoxXMKXkkxxxoooccccccc XMXkxooocccllllllllllcc;,'...',:;lcokK0Xxxoooccclllllll kK0Xxocccllll;;;;;;;;;;l;,'..'',:;lcxk0Kkxoccllll;;;;;; xX0Kkocllll;;;;:::::::::;;,'..',:;lcoxXMXxoclll;;;;;::: okKKkxclll;;;;:::::::,:::;:'..'',:;loxXMXkocll;;;;::::: okK0kxclll;;;:::::::,,,::::,...',:;lcxX0Kkocll;;;;::::: xk0Kkoclll;;;;:::::::::::;:'..',,:;coxXWXxoclll;;;;:::: xXWXxoccllll;;;;;:::::;;c:,...',:;lcokK0kxocclll;;;;;:: k0Kkxooccclllll;;;;;;lcl:,'..',:;lcoxXWXxooocccllll;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ll;;;;;;;;;;;;llllll;;;;;;;;;;;;llcxolllcXocl;;;;;;;;;; .',ol;;;;;;lol:,,,,,;Kl;;;;;;lo:'...........',ll;;;;;;l ....:c;;;;lc,'.......':c;;;;ll'....':;ll:,'....,o;;;;lK ;'...;l;;;l;'.........,o;;;;x'...,xl;;;;;;ll'...:l;;;ll c:...'c;;;;o,'.......'cl;;;l:...'xl;;;;;;;;l;'..'0;;;;c x,...';l;;;;lcc:,,:;xl;;;;;K'...';cl;;;;;;lx,'...:l;;;; '.....';l;;;;;;;;;;;;;;;;lW,.....',;xoookc:,'....':c;;; .......',:ocll;;;;;;llck;,'..........''''.........',:co ...........''''''''''''...............................' ....................................................... '''.............................'',,:::::,,,''......... ;lcl,'......',:;;l;:,''......':xl;;;;;;;;;;;lcc,'...... ;;;;l;'...':Wll;;;;;lo;'....,x;;;;;;;;;;;;;;;;;ll'...., l;;;;l,...,kl;;;;;;;;;c:...'k;;;;lo:,'''',ll;;;;l:...'l :c;;;;c'..'ll;;;;;;;;;o,...:l;;;lc'.......',o;;;;o'..'; :o;;;;l,...':ol;;;;lll,...'X;;;;l;'.......',Xl;;;l:...' xl;;;;;c:'.....'''''.....'ol;;;;;cl,''''',:Wl;;;;;l:'.. ;;;;;;;;lo;,'........'':xl;;;;;;;;;llccccll;;;;;;;;lcl, ;;;;;;;;;;;;llllllllll;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; :coll;;;;;;;;;;;;;;;;;;;;;;;;;lck;,,'''''',:lxll;;;;;;; ...';l;;;;;;lloxllckcl;;;;;;lW,'..............':c;;;;;; '....:l;;;;lo,'....',;c;;;;;X'...',ocllllo;,....,c;;;;l l;'..'0;;;;c:'......',k;;;;l,...,o;;;;;;;;;ll'..'l;;;;l ;c,...:l;;;;o:''...',ol;;;;o'..'cl;;;;;;;;;;c:...,c;;;; lX,...'ll;;;;;llcccl;;;;;;o,...';l;;;;;;;;;lo,...';l;;; ;,'....':cl;;;;;;;;;;;;;lc,.....':Kcllllllcl,'....':xl; '........'',;cKoccoxo;:,'........''',,,,,,''.... ...'',
These were created in extremely simple way, without even using any noise -- each picture here has each pixel computed by plugging the x and y coordinate to a quite simple equation using basic functions like sine, square root, absolute value, triangle wave etc. More complex methods will probably iteratively apply various filters, they may employ things like cellular automata and so on, however here you see even a very simple approach may often be good enough. The C code to generate the pictures above is following (for simplicity using floats and math.h, which in serious programs should be avoided):
{ NOTE: The equations for the functions were made by me when I was playing around with another project. I have uploaded them to Wikimedia Commons, you can find actual png pictures there. ~drummyfish }
#include <stdio.h>
#include <math.h>
#define W 55
#define H 30
// helper stuff:
char palette[] = "WM0KXkxocl;:,'. ";
double min(double a, double b) { return a < b ? a : b; }
double max(double a, double b) { return a > b ? a : b; }
double absMy(double x) { return x < 0 ? -1 * x : x; }
double gauss(double x) { return exp((-1 * x * x) / 2); }
double tri(double x)
{
x = absMy(x);
int whole = x;
double frac = x - whole;
return whole % 2 ? 1 - frac : frac;
}
void drawFunction(double (*f)(double, double), double xFrom, double yFrom,
double xTo, double yTo)
{
double v1 = 0xffffffff, v2 = -1 * v1;
double sX = (xTo - xFrom) / W, sY = (yTo - yFrom) / H;
for (int y = 0; y < H; ++y)
for (int x = 0; x < W; ++x)
{
double v = f(xFrom + x * sX,yFrom + y * sY);
if (v > v2)
v2 = v;
if (v < v1)
v1 = v;
}
v2 -= v1;
if (v2 == 0)
v2 = 0.0001;
for (int y = 0; y < H; ++y)
{
for (int x = 0; x < W; ++x)
putchar(palette[(int) (15 *
((min(v2,max(0,f(xFrom + x * sX,yFrom + y * sY) - v1))) / v2))]);
putchar('\n');
}
}
// ==== ACTUAL INTERESTING FUNCTIONS HERE ===
double fSnakes(double x, double y)
{
return sqrt(tri(x + sqrt(tri(x + 0.4 * sin(y*3)))));
}
double fYinYang(double x, double y)
{
double r = sin(1.2 * y + 2.5 * sin(x) + 2 * cos(2.25 * y) * sin(x));
return log(2 * sqrt(absMy(r)) - r);
}
double fSwirl(double x, double y)
{
return gauss(
fmod((x * x),(absMy(sin(x + y)) + 0.001)) +
fmod((y * y),(absMy(sin(x - y)) + 0.001)));
}
int main(void)
{
drawFunction(fSwirl,-2,-2,2,2);
putchar('\n');
drawFunction(fSnakes,-1,-1,2,2);
putchar('\n');
drawFunction(fYinYang,-4,-4,4,4);
}
Now let's take a look at some iterative algorithm: an extremely simple dungeon generator. This is so called constructive algorithm, a simple kind of method that simply "constructs" something according to given rules, without evaluating how good it's work actually is etc. All it's going to do is just randomly choose a cardinal direction (up, right, down, left), draw a line of random length, and repeat the same from the line's endpoint, until predefined number of lines has been drawn (a kind of random walk). Here is the C code:
#include <stdio.h>
#define W 30 // world width
#define H 30 // world height
char world[H * W]; // 2D world array
unsigned int r = 12345; // random seed here
unsigned int random()
{
r = r * 321 + 29;
return r >> 4;
}
void generateWorld()
{
int steps = 100; // draw this many lines
int pos = 0;
int add = 1; // movement offset
int nextLineIn = 1;
for (int i = 0; i < H * W; ++i)
world[i] = ' ';
while (steps)
{
world[pos] = 'X';
nextLineIn--;
int nextPos = pos + add;
if (nextPos < 0 || nextPos >= W * H || // going over world edge?
(add == 1 && nextPos % W == 0) ||
(add == -1 && nextPos % W == W - 1))
nextLineIn = 0;
else
pos = nextPos;
if (nextLineIn <= 0)
{
steps--;
nextLineIn = W / 5 + random() % (W / 3);
add = (random() & 0x10) ? W : 1;
if (rand() & 0x80)
add *= -1;
}
}
}
int main(void)
{
generateWorld();
for (int i = 0; i < H * W; ++i) // draw
{
char c = world[i];
putchar(c);
putchar(c);
if ((i + 1) % W == 0)
putchar('\n');
}
return 0;
}
And here is one possible output of the program:
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXX XXXX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXX XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXX XXXX XX XX XXXX XX XX X
XXXX XXXX XX XX XXXX XX XX X
XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XX X
XXXX XXXX XX XX XX XXXX XX XX X
XXXX XXXX XX XX XX XXXX XX X
XXXX XXXX XX XX XX XXXX XX X
XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X
XX XX XX XX XX XXXX XX X
XX XX XX XX XX XXXX XX X
XXXXXXXXXXXXXX XX XX XXXX X
XX XX XX XX XX XXXX X
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X
XXXXXXXXXXXXXXXXXXXXXX XX X
XX XX XX XX XX X
XX XX XX XX XX X
XX XX XX XX XX X
XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X
XX XX XX XX XX X
XX XX XX XX XX X
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X
XX XX XX XX XX XX X
XX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XX XX XX XX XX XX X
XX XX XX XXXXXXXXXXXXXXXXXXXXXXXXXXX
XX XX XX XX
XX XX XX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XX
How about some text generation for a change? Let's program a corporate bullshit generator (see also Markov chain):
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
srand(123);
for (int i = 0; i < 10; ++i)
{
switch (rand() % 3)
{
case 0:
printf("To");
switch (rand() % 3)
{
case 0: printf(" us"); break;
case 1: printf(" our highly qualified team"); break;
default: printf(" our company"); break;
}
printf(" it is");
switch (rand() % 5)
{
case 0: printf(" essential"); break;
case 1: printf(" of utmost importance"); break;
case 2: printf(" given"); break;
case 3: printf(" evident"); break;
default: printf(" more than natural"); break;
}
break;
case 1:
printf("We");
switch (rand() % 4)
{
case 0: printf(" believe"); break;
case 1: printf(" know"); break;
case 2: printf(" firmly trust"); break;
default: printf(" hold"); break;
}
break;
default:
printf("Our %s%s %s",
(rand() % 2) ? "founder's " : "",
(rand() % 2) ? "motto" : "highest priority",
(rand() % 2) ? "is" : "has always been");
break;
}
printf(" that");
switch (rand() % 5)
{
case 0: printf(" your business"); break;
case 1: printf(" a brand such as yours"); break;
case 2: printf(" the company you're building"); break;
case 3: printf(" the hard work you put in"); break;
case 4: printf(" image, the driving force of strong marketing,"); break;
default: printf(" exceptional project leadership"); break;
}
switch (rand() % 5)
{
case 0: printf(" deserves"); break;
case 1: printf(" demands"); break;
case 2: printf(" always requires"); break;
case 3: printf(" must be supported by"); break;
default: printf(" should be backed by"); break;
}
switch (rand() % 7)
{
case 0: printf(" dedicated hard work"); break;
case 1: printf(" modern technology"); break;
case 2: printf(" state-of-the-art solutions"); break;
case 3: printf(" valuable feedback"); break;
case 4: printf(" paradigm shifting code reviews"); break;
case 5: printf(" blazing fast integration"); break;
default: printf(" satisfied customers"); break;
}
if (rand() % 2)
{
printf(" and");
switch (rand() % 6)
{
case 0: printf(" unprecedented data evaluation"); break;
case 1: printf(" fair treatment"); break;
case 2: printf(" effective collaboration"); break;
case 3: printf(" professional security"); break;
case 4: printf(" justified profit optimization"); break;
default:
printf(" our %s %s %s",
rand() % 2 ? "team" : "company",
rand() % 2 ? "is proud to" : "will reliably",
rand() % 2 ? "deliver it" : "make it a reality");
break;
}
}
if (rand() % 6 == 0)
printf(rand() % 2 ? " for uncontested prices" : " under fair conditions");
printf(". ");
}
putchar('\n');
return 0;
}
This very simple code still produces a stream of shit almost indistinguishable from anything found on a typical Wordpress business website:
We know that the hard work you put in deserves modern technology and fair treatment under fair conditions. To our company it is evident that a brand such as yours demands modern technology and our team will reliably deliver it. We hold that a brand such as yours demands modern technology. Our motto has always been that your business must be supported by dedicated hard work and our company is proud to make it a reality. To us it is of utmost importance that the company you're building always requires state-of-the-art solutions. Our motto is that the hard work you put in demands paradigm shifting code reviews and our team is proud to make it a reality. To our highly qualified team it is more than natural that the company you're building should be backed by valuable feedback and fair treatment. We hold that the hard work you put in always requires modern technology and justified profit optimization. Our motto has always been that the hard work you put in should be backed by valuable feedback. We firmly trust that a brand such as yours must be supported by satisfied customers.
TODO: some example with noise
Not to be confused with coding.
Programming is the act, science and fine art of writing computer programs; it involves creation of algorithms and data structures and implementing them in programming languages. It may involve related activities such as testing, debugging, hacking and drinking coffee.
You may also encounter the term coding which is used by noob wannabe programmers, so called "coders" or code monkeys. "Coding" doesn't reach the quality of programming, it is done in baby handholding languages like Python, JavaScript or Rust by people with very shallow knowledge of technology and its context, barely qualified to turn on a computer (like jewtubers), who have flooded the computer industry since it turned lucrative. Brian Kernighan in his Software Tools (1976) has said that "controlling complexity is the essence of computer programming" -- try to ask a "coder" what the essence of his "craft" is and he'll rather respond something like "making comfortable tools for the users" or even "making something that works". "Coding" is mostly done for money and/or building an image for oneself. What they do is not real programming. Do not try to imitate them.
At high level programming becomes spiritual. Check out e.g. zen and the famous Tao of Programming (yes, it's kind of a joke but it's rooted in the reality of a common hacker's mindset, programming can truly be kind of a meditation and pursuit of enlightenment, often leading one to asking deeper questions about the world). Many people say that learning programming opens your eyes in a certain new way (with some however claiming the contrary that programming will rather close your eyes), you then see the world like never before (but that's probably kind of true of almost all skills taken to a high level so this may be a shit statement). Others say too much programming cripples you mentally and gives you autism. Anyway it's fun and changes you somehow. Programming requires a good knowledge of advanced math. Wanting to do programming without math is like wanting to do biology without chemistry. Programming also demands probably at least above average IQ, as well as below average social intelligence. Being a white man is an advantage.
Can you do programming without math? Short answer: no. Long answer: no, you can't.
The most epic book series unanimously considered the Bible of programming is the multivolume life work of Donald Knuth called The Art of Computer Programming, as of writing this still unfinished. It's handy to have it around.
See also programming tips and exercises.
Anyone can (and probably should) learn at least the basics of programming -- even if you just aim to maintain a small server or make a website, you will probably have to learn how to write a simple script, and it won't be too difficult, you can learn this from a programming cookbook, just like you can learn to prepare a simple meal without having to become a master chef. Here however we will now assume you aspire to become a GOOD programmer, that you feel programming is something you want to dedicate part of your life to and that it's something you feel joy about for its own sake. How to tell if you're meant for this? You should just feel it. Every true programmer will be able to tell you the story of when he became charmed, when he first saw a computer and realized its potential, when someone showed him a programming language and at that moment the revelation struck him when he saw: "my God, this machine does EXACTLY what I tell it to." Ordinary NPCs just go "oh, that's cool", but the chosen ones just become overwhelmed by excitement, the thought of so many possibilities promptly floods the mind. A normal man perhaps thinks it will simplify his taxes, a true programmer instead can't stop thinking about how to "abuse" and exploit (or more correctly hack) the machine to do what no one thought about before, regardless of practical utility, appreciating just the intellectual value. If this is you, read on.
At first you have to learn two basic rules that have to be constantly on your mind:
OK, now the key thing to becoming a programmer is learning a programming language very well (and learning many of them), however this is not enough (it's only enough for becoming a coding monkey), you additionally have to have a wider knowledge such as general knowledge of computers (electronics, hardware, theory or computation, networks, ...), tech history and culture (free software, hacker cutlure, free culture, ...), math and science in general, possibly even society, philosophy etc. Programming is not an isolated topic (only coding is), a programmer has to see the big picture and have a number of other big brain interests such as chess, voting systems, linguistics, physics, music etc. Remember, becoming a good programmer takes a whole life, sometimes even longer.
Can you become a good programmer when you're old? Well, as with everything to become a SERIOUSLY good programmer you should have probably started before the age of 20, the majority of the legend programmers started before 10, it's just like with sports or becoming an excellent musician. But with enough enthusiasm and endurance you can become a pretty good programmer at any age, just like you can learn to play an instrument or run marathon basically at any age, it will just take longer and a lot of energy. You don't even have to aim to become very good, becoming just average is enough to write simple gaymes and have a bit of fun in life :) Just don't try to learn programming because it seems cool, because you want to look like movie haxor, gain followers on youtube or because you need a job -- if you're not having genuine fun just thinking before sleep about how to swap two variables without using a temporary variable, programming is probably not for you. Can you become a good programmer if you're black or woman? No. :D Ok, maybe you can, but all the above applies, don't do it for politics or money or followers -- if you become a seriously based programmer (from LRS point of view) of unlikely minority, we'll be more than happy to put an apology here, in ALL CAPS and bold letters :) Hopefully this will inspire someone...
Which programming language to start with? This is the big question, it also depends on how talented and hardcore you are. Though languages such as Python or JavaScript are objectively really REALLY bad, they are nowadays possibly the easiest way to get into programming -- at least the "mainstream" kind of -- so you may want to just pick one of these two if you just want to start more slow and casual, knowing you'll abandon the language later to learn a real deal such as C or Forth (and knowing the bad language will still serve you in the future in some ways, it's not a wasted time). Can you start with C right away? It's not impossible for a smart guy but it WILL be hard and there is a big chance you'll end up failing, overwhelmed, frustrated and maybe even never returning to programming again, so be careful. In How To Become A Hacker ESR actually recommends to learn C, Lisp or Go as the first language, but that recommendation really comes to aspiring hackers, i.e. the most talented and ambitious programmers, so think about whether you fit in this category. Absolutely do NOT even consider C# (shit, unusable), Java (shit, slow, bloated, unusable), C++ (like C but shit and more complicated), Haskell (not bad but non-traditional, hard), Rust (shit, bad design, unusable), Prolog (lol) and similar languages -- you may explore some of them later tho (the weird ones, not the bad ones). Whichever language you pick for the love of god avoid OOP -- no matter what anyone tells you, when you see a tutorial that uses "classes"/"objects" just move on, learn normal imperative programming. OOP is a huge pile of shit meme that you will learn anyway later (because everyone writes it nowadays) so that you see why it's shit and why you shouldn't use it. Also don't let them sell you any kind of new shiny paradigm that's currently trending on TikTok -- learn IMPERATIVE PROGRAMMING and cover your ears when someone talks about anything else. So to sum up, here are some comments on individual languages you might consider:
{ I really started programming in Pascal at school, it was actually a good language as it worked very similarly to C and the transition later wasn't that hard. ~drummyfish }
Games are an ideal start project because they're fun (having fun makes learning much faster and enjoyable), there are many noob tutorials all over the Internet etc. However keep in mind to start EXTREMELY simple. -- this can't be stressed enough, most people are very impatient and eager and start making an RPG game or networking library without really knowing a programming language -- this is a GUARANTEED spectacular failure. At the beginning think in terms of "snake" and "minesweeper". Your very first project shouldn't even use any GUI, it should be purely command-line text program, so a text-only tiny interactive story in Python is possibly the safest choice as a first project -- if you are feeling more ambitious, try to write the same thing but in C. Once you're more comfortable you may consider to start using graphics, e.g. Python + Pygame (or, again, C + SAF or SDL if you want a better language), but still KEEP IT SIMPLE, make a flappy bird clone or something. As you progress, consider perhaps buying a simple toy computer such as an open console -- these toys are closer to old computers that had no operating systems etc., they e.g. let you interact directly with hardware and teach you a LOT about good programming by teaching you how computers actually work under the hood AND, by having weak hardware, not allowing you to write shitty code. Whatever language you start with, it is unavoidable that one day you will have to make the big step and learn C, the most important language as of yet, but if you see you're struggling with a simpler language, be sure to only start learning C when you're at least intermediate in your start language (see our C tutorial). To learn C we recommend our SAF library which will save you all headaches of complex APIs and your games will be nice and compatible with you small toy computers.
As with all, you learn by doing -- reading is extremely important and necessary, but to actually learn anything well spending thousands of hours practicing the art is paramount. So program, program and program, live by programming, look for ways of using programming in what you're already doing, try to automate anything you do, think about programming before sleep etc. If you can, contribute to some project, best if you can help your favorite FOSS program -- try this at least once as being in the company of the experienced just teaches you like nothing else, a month spent contributing to a project may be worth two or three years of just reading books. If you're extremely asocial, the alternative is to just fork someone else's program and trying to modify it -- this way you'll at least learn to understand someone else's code and you'll see how someone experienced writes the code.
This section will contain additional useful tips for programming.
#if 0 and #else directives around the two parts. You can switch between them by just changing 0 to 1 and back. This can also disable parts of code that already contain multiline comments (unlike a comment as nested multiline comments aren't allowed).
-Werror -Wall -Wextra -Wpedantic for C.
0xED1B1EFAECE5.
#if defined(_WIN32) || defined(WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__APPLE__) #warning Your OS sucks, go fuck yourself. #endif
Programming language is an artificial formal (mathematically precise) language created in order to let humans relatively easily write algorithms for computers. Such a language essentially allows a man to very specifically and precisely (but still relatively comfortably) tell a computer what to do by expressing an algorithm in textual form. Program written in a programming language is called the program's source code. Programming languages often try to mimic human language -- practically always English -- so as to be somewhat close to humans but programming language is actually MUCH simpler so that a computer can actually analyze it and understand it precisely, as understanding natural human languages poses great difficulty to computers, so in the end programming languages also partially resemble math expressions. Programming languages can be seen as a middle ground between pure machine code (the computer's native language, very hard to handle by humans) and natural language (very hard to handle by computers).
For beginners: a programming language is actually much easier to learn than a foreign language, it will typically have no more than 100 "words" to learn (out of which you'll mostly use like 10) and once you know one programming language, learning another becomes a breeze because they're all (usually) pretty similar in basic concepts. The hard part may be learning some of the concepts if you encounter them for the first time. This is not to say programming is easy -- it is hard, but not because learning the language would be difficult; learning the language is relatively the easier part of programming, the hard parts are for example designing the program's architecture well, designing good protocols and interfaces, learning the math behind the problems you're solving, creating good mathematical models, optimizing and debugging your program well and so on.
A programming language is distinct from a general computer language by its purpose to express algorithms and be used for creation of programs. In other words: there are computer languages that are NOT programming languages (at least in the narrower sense), such as HTML, json and so on. So you shouldn't be calling yourself a programmer if you're just manually writing a website in HTML, people will laugh at you.
We use programming languages to write two basic types of programs: executable programs (programs that can actually be directly run) and libraries (code that cannot be run on its own but is supposed to be reused in other programs, e.g. library with mathematical functions, networking, games and so on).
A simple example of source code in the C programming language is the following:
// simple program computing squares of numbers
#include <stdio.h>
int square(int x)
{
return x * x;
}
int main(void)
{
for (int i = 0; i < 5; ++i)
printf("%d squared is %d\n",i,square(i));
return 0;
}
Which prints:
0 squared is 0 1 squared is 1 2 squared is 4 3 squared is 9 4 squared is 16
We divide programming languages into different groups. Perhaps the most common divisions is to two groups:
Sometimes the distinction between compiled and interpreted languages is not completely clear, for example Python is normally considered an interpreted language but it can also be compiled into bytecode and even native code. Java is considered more of a compiled language but it doesn't compile to native code (it compiles to bytecode). C is traditionally a compiled language but there also exist C interpreters. Comun is meant to be both compiled and interpreted etc. So calling a language interpreted vs compiled is more about what it was designed for, what its priorities are, if the designers made it highly flexible and friendly for interpreting or if they rather intended the code to be efficiently compiled into fast and compact native code.
Another common division is by level of abstraction roughly to (keep in mind the transition is gradual and depends on context, the line between low and high level is extremely fuzzy):
It's possible to divide languages in more distinct ways, for instance based on their paradigm (roughly its core idea/model/"philosophy", e.g. impertaive, declarative, object-oriented, functional, logical, ...), purpose (general purpose, special purpose), computational power (turing complete or weaker, many definitions of a programming language require Turing completeness), typing (strong, weak, dynamic, static) or function evaluation (strict, lazy).
A computer language consists of two main parts:
a / b, semantics says this means the mathematical operation of division and further specifies what a and b can actually be, what happens if b is zero etc. Semantics is the deeper part as firstly it is more difficult to define and secondly it gives the language its features, its power to compute, usability, it can make the language robust or prone to errors, it can make it efficient or slow, easy and hard to compile, optimize etc.We also commonly divide a language to two main parts:
Besides the standard library there will also exist many third party libraries, but these are no longer considered part of the language itself, they are already a products of the language.
What is the best programming language and which one should you learn? (See also programming.) These are the big questions, the topic of programming languages is infamous for being very religious and different people root for different languages like they do e.g. for football teams. For minimalists, i.e. suckless, LRS (us), Unix people, Plan9 people etc., the standard language is C, which is also probably the most important language in history. It is not in the league of the absolutely most minimal and objectively best languages, but it's relatively minimalist (much more than practically any modern language) and has great advantages such as being one of the absolutely fastest languages, being extremely well established, long tested, supported everywhere, having many compilers etc. But C isn't easy to learn as a first language. Some minimalist also promote go, which is kind of like "new C". Among the most minimal usable languages are traditionally Forth and Lisp which kind of compete for who really is the smallest, then there is also our comun which is a bit bigger but still much smaller than C. To learn programming you may actually want to start with some ugly language such as Python, but you should really aim to transition to a better language later on.
Can you use multiple programming languages for one project? Yes, though it may be a burden, so don't do it just because you can. Combining languages is possible in many ways, e.g. by embedding a scripting language into a compiled language, linking together object files produces by different languages, creating different programs that communicate over network etc.
Programmability of the earliest computers was very limited, they were machines with hard-wired functionality and reprogramming them meant physically altering the circuitry or even gears they were made of -- even much later many of the simpler "computers", such as hand held electronic games, weren't running on any programmable CPU or chips of similar nature, but were rather a hand-designed electronic circuit "programmed" by the engineer who manually placed all the resistors and capacitors. However, theoretically, the idea of a programming language had been around for a long time -- in 18th century Basile Bouchon created a system for "programming" looms with what were essentially punch cards and in the first half of the 20th century the universal Turing machine provided a theoretical framework for a fully programmable digital computer that interpreted a kind of language stored on its memory tape, even before there were any "real" computers to speak of. A big step forward then came in 1945 with John Vom Neumann's description of what's now called the Von Neumann architecture, a computer architecture model relying on relatively simple hardware (the CPU) interpreting program stored as numeric instructions in the computer memory (so called stored program), which is exactly the principle of the earlier mentioned universal Turing machine. One of the first such computers was EDSAC constructed in 1949. This "stored program" paradigm showed itself crucial for quick, simple and cheap modification of programs and led to further progress of the computing field -- the focus now shifted from designing individual machines to a more abstract endeavor: that of creating effective, generally usable instruction sets, i.e. machine LANGUAGE now came to play a more central role. Together with more and more abundant transistors finally came computers programmable with what we might call "true languages" -- the first ones were programmed directly in machine code (the numeric instructions), there weren't even any assemblers and assembly languages around, programming involved tasks such as searching for opcodes in computer manuals, hand-encoding data and getting it all onto punch cards -- in better cases it was possible to use some primitive interface such as a "front panel" to program the computer. These kinds of machine languages that were used back then are now called first generation languages.
The first higher level programming language was probably Plankalkul made by Konrad Zuse some time shortly after 1942, though it didn't run on any computer, it was only in stage of specification -- implementation of it would only be made much later, in 1975. It was quite advanced -- it had functions, arrays, exceptions and some advanced data structures, though it for example didn't support recursive calls. It was important as it planted the seed of an idea of an abstract, higher level, machine independent language.
The first assembly language was created by Maurice Wilkes and his team for the mentioned EDSAC computer released in 1949. It used single letters for instructions. Assembly languages are called second generation languages, they further facilitate programming, though still at very low level. These were things we now take for granted: programmers for example became able to type programs as text (instead of numbers), instructions we given human friendlier names and assemblers automated some simple but tedious tasks, but it still remained rather time consuming to write in assembly and programs were still machine specific, non-portable.
Only the third generation languages made the step of adding significant abstraction to achieve a level of comfortable development and portability -- programmers would be able to e.g. write algebraic expressions that would be automatically translated to specific instructions by the language compiler; it would be enough to write the program once and then automatically compile it for different CPUs, without the need to rewrite it. Fortran is considered to be first such language, made in 1957 by IBM. Fortran would develop and change throughout the years, it was standardized and added more "features", it became quite popular and is still used even nowadays, it is known for being very fast. In 1958 John McCarthy started to develop Lisp, a highly elegant, high level language that would spawn many derivatives and remains very popular even nowadays.
During late 60s the term object oriented programming (OOP) appeared, as well as first languages such as Simula and Smalltalk based on this paradigm. Back then it was a rather academic experiment, not really harmful in itself; later on OOP would be seized and raped by capitalists to break computers. In 1964 the language called BASIC appeared with the goal to facilitate programming to non-professionals and reached popularity as a language for home computers. On a similar note in 1970 Pascal was created as an educational language -- some hackers already saw this as too much of a retardation of programming languages (see the legendary rant called Real Programmers Don't Use Pascal essay).
One of the most notable events in history of programming languages was the invention of the C language in 1972 by Dennis Ritchie and Brian Kerninghan who used it as a tool for their Unix operating system. The early version C was quite different from today's C but the language as a whole is undoubtedly the most important one in history -- it's not the most elegant one but it achieved the exactly correct mixture of features, simplicity and correct design choices such as allowing freedom and flexibility of implementation that would in turn lead to extreme efficiency and adoption by many, to standardization, further leading to many implementations and their high optimization which in turned increased C's popularity yet more and so on. From this point on new languages would typically in one way or another try to iterate on C. Also in 1972 the first esoteric programming language -- INTERCAL -- was created as kind of parody language. This would create a dedicated community of people creating similar "funny" language, which is highly active even today.
In 1978 the Intel 8086 CPU was released, giving rise to the x86 assembly language -- the assembly that would become perhaps the most widely used ones, owing to the popularity of Intel CPUs. In 1979 Bjarne Stroustrup sadly started to work on C++, a language that would rape the concept of object oriented programming introduced by languages like Simula and Smalltalk in a highly twisted, capitalist way, starting the trend of creating ugly, bloated languages focused on profit making.
Just before the 90s, in the year of our Lord 1989, the ANSI C standard (also known as C89) was released -- this is considered one of the best C standards. In 1991 Java, a slow, bloated, purely capital-oriented language with FORCED OOP started to be developed by Sun Microsystems. This was a disaster, it would lead to completely fucking up computer for ever after. In the same year Python -- a language for retards -- appeared, which would also greatly contribute to destroying computer technology in a few decades. Meanwhile after some spark of renewed interest in esoteric languages Brainfuck was made in 1993 and went on to become probably the most popular among esoteric languages -- this was at least one good events. However in 1995 another disaster struck when JavaScript was announced, this would later on completely destroy the whole web. At the end of 90s, in 1999, the other one of the two best C standards -- C99 -- was released. This basically marks the end of good events in the world of programming languages, with some minor exceptions such as the creation of comun in 2022.
What really IS a programming language -- is it software? Is it a standard? Can a language be bloated? How does the languages evolve? Where is the exact line between a programming language and non-programming language? Who makes programming languages? Who "owns" them? Who controls them? Why are there so many and not just one? These are just some of the questions one may ask upon learning about programming. Let's try to quickly answer some of them.
Strictly speaking programming language is a formal language with semantics, i.e. just something akin to a "mathematical idea" -- as such it cannot be directly "owned", at least not on the grounds of copyright, as seems to have been quite strongly established by a few court cases now. However things related to a language can sadly be owned, for example their specifications (official standards describing the language), trademarks (the name or logo of the language), implementations (specific software such as the language's compiler), patents on some ideas used in the implementation etc. Also if a language is very complex, it can be owned practically; typically a corporation will make an extremely complicated language which only 1000 paid programmers can maintain, giving the corporation complete control over the language -- see bloat monopoly and capitalist software.
At this point we should start to distinguish between the pure language and its implementation. As has been said, the pure language is just an idea -- this idea is explained in detail in so called language specification, a document that's kind of a standard that precisely describes the language. Specification is a technical document, it is NOT a tutorial or promotional material or anything like that, its purpose is just to DEFINE the language for those who will be implementing it -- sometimes specification can be a very official standard made by some standardizing organization (as e.g. with C), other times it may be just a collaborative online document that at the same time serves as the language reference (as e.g. with Lua). In any case it's important to version the specification just as we version programs, because when specification changes, the specified languages usually changes too (unless it's a minor change such as fixing some typos), so we have to have a way to exactly identify WHICH version of the language we are referring to. Theoretically specification is the first thing, however in practice we usually have someone e.g. program a small language for internal use in a company, then that language becomes more popular and widespread and only then someone decides to standardize it and make the official specification. Specification describes things like syntax, semantics, conformance criteria etc., often using precise formal tools such as grammars. It's hugely difficult to make good specification because one has to decide what depth to go to and even what to purposefully leave unspecified! One would thought that it's always better to define as many things as possible, but that's naive -- leaving some things up to the choice of those who will be implementing the language gives them freedom to implement it in a way that's fastest, most elegant or convenient in any other way.
It is possible for a language to exist without official specification -- the language is then basically specified by some of its implementations, i.e. we say the language is "what this program accepts as valid input". Many languages go through this phase before receiving their specification. Language specified purely by one implementation is not a very good idea because firstly such specification is not very readable and secondly, as said, here EVERYTHING is specified by this one program (the language EQUALS that one specific compiler), we don't know where the freedom of implementation is. Do other implementations have to produce exactly the same compiled binary as this one (without being able to e.g. optimize it better or produce binaries for other platforms)? If not, how much can they differ? Can they e.g. use different representation of numbers (may be important for compatibility)? Do they have to reproduce even the same bugs as the original compiler? Do they have to have the same technical limitations? Do they have to implement the same command line interface (without potentially adding improvements)? Etc.
Specification typically gets updated just as software does, it has its own version and so we then also talk about version of the language (e.g. C89, C99, C11, ...), each one corresponding to some version of the specification.
Now that we have a specification, i.e. the idea, someone has to realize it, i.e. program it, make the implementation; this mostly means programming the language's compiler or interpreter (or both), and possibly other tools (debugger, optimizer, transpiler, etc.). A language can (and often does) have multiple implementations; this happens because some people want to make the language as fast as possible while others e.g. want to rather have small, minimalist implementation that will run on limited computers, others want implementation under a different license etc. The first implementation is usually so called reference implementation -- the one that will serve as a kind of authority that shows how the language should behave (e.g. in case it's not clear from the specification) to those who will make newer implementations; here the focus is often on correctness rather than e.g. efficiency or minimalism, though it is often the case that reference implementations are among the best as they're developed for longest time. Reference implementations guide development of the language itself, they help spot and improve weak points of the language etc. Besides this there are third party implementations, i.e. those made later by others. These may add extensions and/or other modifications to the original language so they spawn dialects -- slightly different versions of the language. We may see dialects as forks of the original language, which may sometimes even evolve into a completely new language over time. Extensions of the languages may sound like a good thing as they add more "comfort" and "features", however they're usually bad as they create a dependency and fuck up the standardization -- if someone writes a program in a specific compiler's dialect, the program won't compile under other compilers.
A new language comes to existence just as other things do -- when there is a reason for it. I.e. if someone feels there is no good language for whatever he's doing or if someone has a brilliant idea and want to write a PhD thesis or if someone smokes too much weed or if a corporation wants to control some software platform etc., a new language may be made. This often happen gradually (again, like with many things), i.e. someone just starts modifying an already existing language -- at first he just makes a few macros, then he starts making a more complex preprocessor, then he sees it's starting to become a new language so he gives it a name and makes it a new language -- such language may at first just be transpiled to another language (often C) and over time it gets its own full compiler. At first a new language is written in some other language, however most languages aim for self hosted implementation, i.e. being written in itself. This is natural and has many advantages -- a language written in itself proves its maturity, it becomes independent and as it itself improves, so does its own compiler. Self hosting a language is one of the greatest milestones in its life -- after this the original implementation in the other language often gets deletes as it would just be a burden to keep maintaining it.
So can a language be inherently fast, bloated, memory efficient etc.? When we say a language is so and so, we generally refer to its implementations and our experience from practice because, as explained previously, a language in itself is only an idea that can be implemented in many ways with different priorities and tradeoffs, and not only that; even if we choose specific implementations of languages, the matter of benchmarking and comparing them is very complicated because the results will be highly dependent for example on hardware architecture we use (some ISA have slow branching, lack the divide instruction, some MCUs lack floating point unit etcetc., all of which may bias results heavily to either side) AND on test programs we use (some types of problems may better fit the specialization of one language that will do very well at it while it would do much worse at other types of problems), the way they are written (the problem of choosing idiomatic code vs transliteration, i.e. performance will depend on whether we try to solve the benchmark problem in the way that's natural for the language or the way that's more faithful to the described solution) and what weight we give to each one (i.e. even when using multiple benchmarks, we ultimately have to assign a specific importance to each one). It's a bit like trying to say who the fastest human is -- generally we can pick the top sportsmen in the world but then we're stuck because one will win at sprint while the other one at long distance running and another one at swimming, and if we consider even letting them compete in different clothes, weather conditions and so on, we'll just have to give up. So speaking about languages and their quantitative properties in practice generally means talking about their implementations and practical experience we have. HOWEVER, on the other hand, it does make sense to talk about properties of languages as such as well -- a language CAN itself be seen as inherently having some property if it's defined so that its every implementation has to have this property, at least practically speaking. Dynamic typing for example means the language will be generally slower because operations on variables will inevitably require some extra runtime checks of what's stored in the variable. A very complicated language just cannot be implemented in a simple, non-bloated way, an extremely high level and flexible language cannot be implemented to be among the fastest -- so in the end we also partially speak about languages as such because eventually implementations just reflect the abstract language's properties. How to tell if a language is bloated? One can get an idea from several things, e.g. list of features, paradigm, size of its implementations, number of implementations, size of the specification, year of creation (newer mostly means more bloat) and so on. However be careful, many of these are just heuristics, for example small specification may just mean it's vague. Even a small self hosted implementation doesn't have to mean the language is small -- imagine e.g. a language that just does what you write in plain English; such language will have just one line self hosted implementation: "Implement yourself." But to actually bootstrap the language will be immensely difficult and will require a lot of bloat.
Judging languages may further be complicated by the question of what the language encompasses because some languages are e.g. built on relatively small "pure language" core while relying on a huge library, preprocessor, other embedded languages and/or other tools of the development environment coming with the language -- for example POSIX shell makes heavy use of separate programs, utilities that should come with the POSIX system. Similarly Python relies on its huge library. So sometimes we have to make it explicitly clear about this.
Here is a table of notable programming languages in chronological order (keep in mind a language usually has several versions/standards/implementations, this is just an overview).
| language | minimalist/good? | since | speed | mem. | ~min. selfhos. impl. LOC | DT LOC | spec. (~no stdlib pages) | notes |
|---|---|---|---|---|---|---|---|---|
| pseudocode | ??? | ??? | ??? | ??? | ??? | ??? | not really a single, strictly defined language, but often used | |
| Lambda calculus | yes | 1936 | 1 | mathematical functional language, not used for practical programming | ||||
| "assembly" | yes but... | 1947? | NOT a single language, non-portable | |||||
| Fortran | kind of | 1957 | 1.95 (G) | 7.15 (G) | 300, proprietary (ISO) | similar to Pascal, compiled, fast, was used by scientists a lot | ||
| Lisp(s) | yes | 1958 | 3.29 (G) | 18 (G) | 100 (judg. by jmc lisp) | 35 | 40 (r3rs) | elegant, KISS, functional, many variants (Common Lisp, Scheme, ...) |
| Basic | kind of? | 1964 | mean both for beginners and professionals, probably efficient | |||||
| Cobol | prolly not much | 1959 | some kind of weird "business oriented" language, looks like shit | |||||
| Forth | YES | 1970 | 100 (judg. by milliforth) | 77 | 200 (ANS Forth) | stack-based, elegant, very KISS, interpreted and compiled | ||
| Pascal | kind of | 1970 | 5.26 (G) | 2.11 (G) | 59 | 80, proprietary (ISO) | like "educational C", compiled, not so bad actually | |
| C | kind of | 1972 | 1.0 | 1.0 | 10K? (judg. by chibicc) | 49 | 160, proprietary (ISO) | compiled, fastest, efficient, established, suckless, low-level, #1 lang. |
| Prolog | maybe? | 1972 | logic paradigm, hard to learn/use | |||||
| Smalltalk | quite yes | 1972 | 47 (G) | 41 (G) | 40, proprietary (ANSI) | PURE (bearable kind of) OOP language, pretty minimal | ||
| C++ | no, bearable | 1982 | 1.18 (G) | 1.27 (G) | 51 | 500, proprietary | bastard child of C, only adds bloat (OOP), "games" | |
| Ada | ??? | 1983 | { No idea about this, sorry. ~drummyfish } | |||||
| Object Pascal | no | 1986 | Pascal with OOP (like what C++ is to C), i.e. only adds bloat | |||||
| Objective-C | probably not | 1986 | kind of C with Smalltalk-style "pure" objects? | |||||
| Oberon | kind of? | 1987 | simplicity as goal, part of project Oberon | |||||
| Perl | rather not | 1987 | 77 (G) | 8.64 (G) | interpreted, focused on strings, has kinda cult following | |||
| Bash | well | 1989 | Unix scripting shell, very ugly syntax, not so elegant but bearable | |||||
| Haskell | kind of | 1990 | 5.02 (G) | 8.71 (G) | 150, proprietary | functional, compiled, acceptable | ||
| Python | NO | 1991 | 45 (G) | 7.74 (G) | 32 | 200? (p. lang. ref.) | interpreted, huge bloat, slow, lightweight OOP, artificial obsolescence | |
| POSIX shell | well, "kind of" | 1992 | 50, proprietary (paid) | standardized (std 1003.2-1992) Unix shell, commonly e.g. Bash | ||||
| Brainfuck | yes | 1993 | 100 (judg. by dbfi) | 1 | extremely minimal (8 commands), hard to use, esolang | |||
| FALSE | yes | 1993 | 1 | very small yet powerful, Forth-like, similar to Brainfuck | ||||
| Lua | quite yes | 1993 | 91 (G) | 5.17 (G) | 7K (LuaInLua) | 40, free | small, interpreted, mainly for scripting (used a lot in games) | |
| Java | NO | 1995 | 2.75 (G) | 21.48 (G) | 800, proprietary | forced OOP, "platform independent" (bytecode), slow, bloat | ||
| JavaScript | NO | 1995 | 8.30 (G) | 105 (G) | 50K (est. from QuickJS) | 34 | 500, proprietary? | interpreted, the web lang., bloated, classless OOP |
| PHP | no | 1995 | 23 (G) | 6.73 (G) | 120 (by Google), CC0 | server-side web lang., OOP | ||
| Ruby | no | 1995 | 122 (G) | 8.57 (G) | similar to Python | |||
| C# | NO | 2000 | 4.04 (G) | 26 (G) | proprietary (yes it is), extremely bad lang. owned by Micro$oft, AVOID | |||
| D | no | 2001 | some expansion/rework of C++? OOP, generics etcetc. | |||||
| Rust | NO! lol | 2006 | 1.64 (G) | 3.33 (G) | 0 :D | extremely bad, slow, freedom issues, toxic community, no standard, AVOID | ||
| Go | kind of maybe | 2009 | 4.71 (G) | 5.20 (G) | 130, proprietary? | "successor to C" but not well executed, bearable but rather avoid | ||
| LIL | yea | 2010? | not known too much but nice, "everything's a string" | |||||
| uxntal | yes but SJW | 2021 | 400 (official) | 2? (est.), proprietary | assembly lang. for a minimalist virtual machine, PROPRIETARY SPEC. | |||
| T3X/0 | yes | 2022 | 4K | 66 | 130, proprietary | T3X family, minimalist, Pascal-like | ||
| comun | yes | 2022 | 4K | 76 | 2, CC0 | "official" LRS language, WIP, similar to Forth |
NOTES on the table above:
speed/mem. column says a benchmarked estimate running time/memory consumption of the best case (best compiler, best run, ...) relateive to C (i.e. "how many times the language is worse than C"). The data may come from various sources, for example the The Computer Language Benchmark Game (G), own measurement (O) etc.
TODO: Tcl, Rebol
Some programming languages may be interesting rather than directly useful -- following this trail may lead you to more obscure and underground programming communities -- however these languages are important too as they teach us a lot and may help us design good practically usable languages. In fact professional researches in theory of computation spend their whole lives dealing with practically unusable languages and purely theoretical computers. Even a great painter sometimes draws funny silly pictures in his notebook, it helps build a wide relationship with the art and you never know if a serious idea can be spotted in a joke.
One such language is e.g. Unary, a programming language that only uses a single character while being Turing complete (i.e. having the highest possible "computing power", being able to express any program). All programs in Unary are just sequences of one character, differing only by their length (i.e. a program can also be seen just as a single natural number, the length of the sequence). We can do this because we can make an ordered list of all (infinitely many) possible programs in some simple programming language (such as a Turing machine or Brainfuck), i.e. assign each program its ordinal number (1st, 2nd, 3rd, ...) -- then to express a program we simply say the position of the program on the list.
There is a community around so called esoteric programming languages which takes great interest in such languages, from mere jokes (e.g. languages that look like cooking recipes or languages that can compute everything but can't output anything) to discussing semi-serious and serious, even philosophical and metaphysical questions. They make you think about what really is a programming language; where should we draw the line exactly, what is the absolute essence of a programming language? What's the smallest thing we would call a programming language? Does it have to be Turing complete? Does it have to allow output? What does it even mean to compute? And so on. If you dare, kindly follow the rabbit hole.
The word proprietary (related to the word property) describes intellectual works (such as texts, songs, computer programs, ...) that are not free as in freedom, i.e. a proprietary work is one that is someone's "intellectual property" (owned on grounds of copyright, patents, trademarks etc.) that denies others at least one of the four essential freedom conditions agreed upon by movements such as free software or free culture. The word proprietary has a completely negative connotation, for such works serve capitalist oppressors, their aim is to abuse and suppress freedom. The opposite of proprietary is therefore free as in freedom (also libre): free works are either those which are completely public domain or those technically "owned" by someone but accompanied by a free (as in freedom) license that voluntarily waives all the most harmful legal "rights" (more correctly opportunities of oppression) of the "owner". There are two main kinds of proprietary works (and their free counterparts): proprietary software (as software was the first area where these issues arose) (versus free software) and other proprietary art of other kind (music, pictures, data, ...) (versus free cultural art).
Proprietary software is commonly agreed to be evil; it is mostly capitalist software designed to abuse its user in one way or another. Proprietary code is often secret, not publicly accessible, although it's not uncommon to come across programs whose source code is available but which is still proprietary because no one except the "owner" has the necessary legal rights to using it, studying it, fixing it, improving it and/or redistributing it.
Examples of proprietary software are MS Windows, MacOS, Adobe Photoshop and nearly every videogame. Proprietary software does not only do extraordinary harm to culture, technology and society as such, it is downright dangerous and on occasion life-threatening; see for example cases of medical implants such as pacemakers running secret proprietary code whose creator and maintainer goes out of business and can no longer continue to maintain such devices already planted into bodies of humans -- such situations have already appeared, see e.g. Autonomic Technologies nervous system implants.
Proprietary software licenses are usually called EULAs.
By extension besides proprietary software we also encounter other types of proprietary works, for instance proprietary art or databases -- these are all works that are not free cultural works. Although for example a proprietary movie probably isn't IMMEDIATELY and DIRECTLY as dangerous as proprietary software, it may well pose the same danger to society in the long run. Examples of proprietary art is basically anything mainstream that's not older than let's say 50 years: Harry Potter, all Hollywood movies, basically all pop music, virtually all AAA video game art and so forth.
Is it ever fine to use proprietary software? If you have to ask, the answer is no, you should avoid proprietary software as much as possible (considering in today's society you probably can't even take a shit without using some form of proprietary software). Proprietary software is cancer, it is like hard drugs, poison, radioactive toxic material, biological virus -- you have to treat it as such. For this reason to most people, especially newcomers to the free world, the best, simplest and safest advice is to completely avoid anything proprietary; this helps you get out of the addiction, break out of the system, find free alternatives and avoid harm to yourself and others. Once one becomes an expert he start to see the answer may be more complex of course, as with everything -- for example in order to make a free clone of something proprietary, we often have to reverse engineer it, which often means having to run it; however this has to only be done by experts who know the dangers and how to handle them, just like handling of a highly dangerous biological virus should only ever be done by an expert in safe laboratory under strictly controlled conditions.
Pseudorandom data is data that appears (for example by its statistical properties) to have been generated by a random process despite in fact having been generated by a deterministic (i.e. non-random) process. I.e. it's a kind of "fake" but mostly good enough randomness that arises from chaotic systems -- systems that behave without randomness, by strict rules, but which scramble, shuffle, twist and transform the numbers in such a complicated way that they eliminate obvious patterns and leave the data looking very "random", though the numbers would be scrambled exactly the same way if the process was repeated with the same conditions, i.e. it is possible (if we know how the generator works) to exactly predict which numbers will fall out of a pseudorandom generator. This is in contrast to "true randomness" that (at least to what most physicists probably think) appears in some processes in nature (most notably in quantum physics) and which are absolutely unpredictable, even in theory. Pseudorandomness is typically used to emulate true randomness in computers because for many things (games, graphics, audio, random sampling, ...) it is absolutely sufficient, it is easy to do AND the repeatability of a pseudorandom sequence is actually an advantage to engineers, e.g. in debugging in which we have to replicate bugs we find, or in programs that simply have to behave deterministic (e.g. many network games). True randomness is basically only ever needed for cryptography/security (or possibly for rare applications where we absolutely NEED to ensure lack of any patterns in the data), it is a bit harder to achieve because we need some unbiased source of real-world random data. Pseudorandom generators are so common that in most contexts in programming the word "random" silently actually means just "pseudorandom".
A saying about psedorandom numbers states that "randomness is a task too important to be left to chance".
Pseudorandom numbers are not to be confused with quasirandom numbers (AKA low discrepancy sequences) which are imitating randomness yet in a weaker way (just attempting to be spaced far apart).
Firstly let's mention that we can use look up tables, i.e. embed some high quality random data right into our program and then use that as our random numbers, taking one after another and getting back to start once we run out of them. This is for example how Doom's pseudorandom generator worked. This is easy to do and extremely fast, but will take up some memory and will offer only a quite limited sized sequence (your generator will have a short period), so ponder on the pros and cons for your specific needs. From now on we'll leave this behind and will focus on really GENERATING the pseudorandom values with some algorithm, but look up tables may still be kept in mind (they might even perhaps be somehow combined with the true generators).
There are possibly many ways to approach generating pseudorandom numbers (for example you can just run some chaotic cellular automaton, such as rule 30, and then convert it to numbers somehow), however we'll be describing the most typical way, used in implementation of programming languages etc.
Pseudorandom generators generate an infinite (but in practice eventually repeating) sequence of numbers from some initial starting number which we call a seed (i.e. it's important to rather think of sequences than of individual "random numbers" -- a number itself can hardly be random). Because pseudorandom generators are deterministic, the same seed number will always result in the same sequence of numbers (of course assuming we use the same generator). If you ask the generator for the next pseudorandom number, it just generates the next number in the sequence and passes it to you. This can sometimes present a challenge for programs that want to appear random. Imagine for instance a random image generator -- if we hardcoded the seed, the program would always generate the exact same image because it would be painting it based on a number sequence that's always the same. This is solved by ensuring the seed is different during each run, and that can be done in several ways. A common solution is to use real time as the seed, e.g. using the Unix timestamp or the computer's uptime in milliseconds etc., but some languages may be unable to obtain these values for various reasons, so we may also let the user enter the seed manually (e.g. as a command line flag). If a source of "truly random" data exists (such as the /dev/random file on Unices, or maybe even some lower bits in temperature sensors or something similar), it is an ideal way to set the seed. Interactive programs can also resort to computing the seed from its user's behavior, e.g. his mouse movement or the frame number at which he pressed the start button in the splash screen.
The next number in the sequence is typically only generated from the previous number by performing some chaotic operations with it that transform it into a new number. However this is not entirely true because then the generator would have the following weakness: if it generated number A and then B, then every number A would ALWAYS be followed by number B -- that doesn't look exactly random and there would probably soon appear a very short repeating cycle. For this reason the generator internally keeps a big number with which it operates and it only returns some N bits (for example the highest 16 bits) of that number to you. This way it is possible (from your point of view) to have the same number be followed by different numbers (though this doesn't hold for the generator's internal value of course, but that doesn't bother us, we are only looking at the output sequence).
The number of bits that the generator takes from its internal number and gives you determines the range of random values that you can get. For example if the generator gives you 16 bit numbers, you know the numbers will be in range 0 to 65535. (This can be used to also generate numbers in any range but we'll look at that later.)
Now let's realize another important thing -- if the generator has some internal number, which is the only thing that determines the next number, and if its internal number has some limited size -- let's say for example 32 bits -- then the sequence HAS TO start repeating sometimes because there is a limited number of values the internal number can be in and once we get to the same number, it will have to evolve the same way it evolved before (because we have a deterministic generator and the number is the whole generator's state). Imagine this as a graph: numbers are nodes, the seed is the node we start in, there are finitely many nodes and each one leads to exactly one other node -- going through this graph you inevitably have to end up running in some loop. For this reason we talk about the period of a pseudorandom generator -- this period says after how many values the sequence will start to repeat. In fact it is possible that only last N values of the initial sequence will start to repeat -- again, if you imagine the graph, it is possible that an initial path leads us to some smaller loop in which we then keep cycling. This may depend on the seed, so the whole situation can get a bit messy, but we can resolve this, just hold on.
It's not hard to see that the period of the generator can be at most 2 to the power of the number of bits of the generator's internal value (i.e. the number of possible distinct values the number can be, or the nodes in the graph). We want to achieve this maximum period -- indeed, it is ideal if we can make it as long as possible, but achieving the maximum period will also mean the period won't depend on the initial seed! If you imagine the graph, having a big loop over all the values means that there are no other loops, there's just one long repeating sequence in which each internal value appears exactly once, so no matter where we start (which seed we set), we'll always end up being in the same big loop. In addition to this we ALSO get another awesome thing: the histogram (the count) of all values over the whole period will be absolutely uniform, i.e. every value generated during one period will appear exactly the same number of times (which is what we expect from a completely random, uniform generator) -- this can be seen from the fact that we are returning N bits of some bigger internal number of N + M bits, which will come through each possible value exactly once, so each possible value of N will have to appear and each of these values will have to appear with all possible values of the remaining M bits, which will be the same for all values.
Now let's take a look at specific generators, i.e. types of algorithms to generate the numbers. There are many different kinds, for example Mersenne Twister, middle square etc., however probably the most common type is the linear congruential generator (LCG) -- though for many decades now it's been known this type of generator has some issues (for example less significant bits have shorter and shorter periods, for which we usually want to use a very big internal value and return its highest bits as the result), it will likely suffice for most of your needs, but you have to be careful about choosing the generator's parameters correctly. It works like this: given a current (internal) number x[n] (which is initially set to the seed number), the next number in the sequence is computed as
`x[n + 1] = (A * x[n] + C) mod M
where A, C and M are constants -- these are the parameters of the generator. I.e. the next number in the sequence is computed by taking the current number, multiplying it by some constant, adding some constant and then taking modulo (remainder after division) of this by some constant. The catch is in choosing the right constants A, C and M -- it seems there are only a few combinations of these constants that will yield quality sequences. Furthermore we try to make the equation fast to compute, so we often aim to choose M to be some power of two -- if we are for example using 32 bit numbers, then choosing M to be 2^32 is extremely convenient, we simply let the number overflow (the overflow does the same thing as modulo by 2^32) or, at worse, perform a simple logical and to mask out the lowest bits. It would be cool to also have A a power of two because then also the multiplication would be very fast and simple (just a bit shift), BUT this can't really be done because then the multiplication wouldn't actually achieve much randomness, it would just shift the number left, meaning the higher bits of x[n + 1] would really be the same (or at least corelated with) the lower bits of x[n].
So how to choose the A, C and M constants? Let's say we take M to be a power of two, for reasons stated above. Now it is proven (Hull-Dobell theorem) that we'll get the maximum possible period (the thing we absolutely WANT) if exactly all of the following conditions hold: M and C must have the highest common divisor 1 (i.e. they must be coprime) AND A - 1 is divisible by all prime factors of M AND A - 1 is divisible by 4 if M is divisible by 4. So basically we want all of these conditions to always hold -- however even if they hold, we don't necessarily have a statistically good generator yet (to ensure this see the tests below). The value of C isn't very significant, it's enough if the above conditions hold for it, so many just use e.g. 1 or some prime number, but choosing A correctly turns out to be quite hard.
Here is a template for a C linear congruential generator:
T _currentRand; // the internal number
void randomSeed(unsigned int seed)
{
_currentRand = seed;
}
unsigned int random()
{
_currentRand = A * _currentRand + C;
return _currentRand >> S;
}
Here T is the data type of the internal number (implying the M constant) -- use some fixed width type from stdint.h here. A is the multiplicative constant, C is the additive constant and S is a shift that implies how many highest bits of the internal number will be taken (and therefore what range of numbers we'll be getting). The following table gives you a few hopefully good values you can just plug into this snippet to get an alright generator:
T | A | C | S | note | sequence sample (starting from 100th number) |
|---|---|---|---|---|---|
uint32_t | 32310901 | 37 | 16 or 24 | A from L'Ecuyer | 38118, 197, 28170, 11612, 21102, 63207, 2572, 21309, 59711, 17284, ... |
uint32_t | 2891336453 | 123 | 16 or 24 | A from L'Ecuyer | 31804, 54678, 21911, 47965, 33591, 23969, 38804, 659, 5011, 43707, ... |
uint32_t | 2147001325 | 715136305 | 16 | from Entacher 1999 | 40401, 62120, 18120, 47981, 63951, 61090, 35627, 51189, 49566, 13666, ... |
uint32_t | 22695477 | 1 | 16 | from Entacher 1999 | 61458, 34169, 50905, 16735, 20343, 25267, 41080, 39879, 40501, 10993, ... |
uint64_t | 2862933555777941757 | 12345 | 32 or 48 | A from L'Ecuyer | 2204069570, 3565223070, 71446738, 528880356, 4046402086, 3687091948, ... |
uint64_t | 3935559000370003845 | 1719 | 32 or 48 | A from L'Ecuyer | 3897855749, 430815323, 2783259848, 156663604, 2365550848, 2624048926, ... |
{ I pulled the above numbers from various sources I found, mentioned in the note, tried to select the ones that were allegedly good, I also quickly tested them myself, checked the period was at maximum at least for the 32 bit generators and lower and ran it through ent which reported good results. ~drummyfish }
Let's also quickly mention another kind of generator as an alternative -- the middle square plus Weyl sequence generator. Middle square generator was one of the first and is very simple, it simply starts with a number (seed), squares it, takes its middle digits as the next number, squares it, takes its middle digits and so on. The issue with this was mainly getting a number 0, at which we get stuck. A 2022 paper by Wydinski seems to have solved this issue by employing so called Weyl sequence -- basically just adding some odd number in each step, though the theory is a bit more complex, the paper goes on to prove a high period of this generator. An issue seems to be with seeding the sequence -- the generator has three internal numbers and they can't just be blindly set to "anything" (the paper gives some hints on how to do this). Here is a 32 bit variant of such generator (the paper gives a 64 bit one):
{ I tried to make a 32 bit version of the generator, tried to choose the _rand3 constant well -- after quickly testing this the values of the generator looked alright, though I just mostly eyeballed the numbers, each bit separately, checked the mean of some 4000 values and the histogram of 1 million values. I also ran this through ent and it gave good results except for the chi square test that reported the rarity of the sequence at something over 5% (i.e. not impossible, but something like 1 in 20 chance). I'm not claiming this version to be statistically good, but it may be a start for implementing something nice, use at own risk. ~drummyfish }
#include <stdint.h>
uint32_t _rand1, _rand2, _rand3 = 0x5e19dbae;
uint16_t random()
{
_rand2 += _rand3;
_rand1 = _rand1 * _rand1 + _rand2;
_rand1 = (_rand1 >> 16) | (_rand1 << 16);
return _rand1;
}
NOTE on the code: the (_rand1 >> 16) | (_rand1 << 16) operation effectively makes the function return lower 16 bits of the squared number's middle digits, as multiplying _rand1 (32 bit) by itself results in the lower half of a 64 bit result.
The obtained sequence starts as: 24089, 36550, 36617, 6030, 11432, 62341, 37282, 32467, 23029, 26116, 63979, 36493, ...
Yet another idea might be to use some good hash just on numbers 1, 2, 3, 4 ... The difference here is we are not computing the pseudorandom number from the previous one, but we're computing Nth pseudorandom number directly from N. This will probably be slower per a single function call, but may be advantageous and overall faster in certain scenarios (imagine for instance a procedurally generated animation that's rewound very far forward: to draw the current frame we'll need Nth number of the pseudorandom sequence and the hash approach gives it to us quickly and in constant time, whereas the traditional way would have to compute the whole sequence from start). For example: { Again, no big guarantees, but I ran this through ent again and got very good results. ~drummyfish }
#include <stdint.h>
uint32_t _rand = 0;
uint32_t random(void)
{
uint32_t x = _rand;
_rand++;
x = 303484085 * (x ^ (x >> 15));
x = 985455785 * (x ^ (x >> 15));
return x ^ (x >> 15);
}
void randomSeed(uint32_t seed)
{
_rand = seed; // this alone just offsets the sequence
seed = random(); // this is an attempt at fix
}
This generates a sequence starting with: 0, 3768839452, 4227911003, 1223184510, 4160985782, 2003897881, 3431987483, 2357500583, 4026873197, 1007578691, 698404316, 753669850, ...
How to generate a number in certain desired range? As said your generator will be giving you numbers of certain fixed number of bits, usually something like 16 or 32, which means you'll be getting numbers in range 0 to 2^bits - 1. But what if you want to get numbers in some specific range A to B (including both)? To do this you just need to generate a number in range 0 to B - A and then add A to it (e.g. to generate number from 20 to 30 you generate a number from 0 to 10 and add 20). So let's just suppose we want a number in range 0 to N (where N can be B - A). Let's now suppose N is lower than the upper range of our generator, i.e. that we want to get the number into a small range (if this is not the case, we can arbitrarily increase the range of our generator simply by generating more random bits with it, i.e we can join two 16 bit numbers to get a 32 bit number etc.). Now the most common way to get the number in the desired range is by using modulo (N + 1) operation, i.e. in C we simply do something like int random0to100 = random() % 101;. This easily forces the number we get into the range we want. HOWEVER beware, there is one statistical trap about this called the modulo bias that makes some numbers slightly more likely to be generated than others, i.e. it biases our distribution a little bit. For example imagine our generator gives us numbers from 0 to 15 and we want to turn it into range 0 to 10 using the modulo operator, i.e. we'll be doing mod 11 operation -- there are two ways to get 0 (0 mod 11 and 11 mod 11) but only one way to get 9 (9 mod 11), so number 0 is twice as likely here. In practice this effect isn't so strong and in many situations we don't really mind it, but we have to be aware of this effects for the sake of cases where it may matter. If necessary, the effect can be reduced -- we may for example realize that modulo bias will be eliminated if the upper range of our generator is a multiple of the range into which we'll be converting, so we can just repeatedly generate numbers until it falls under a limit that's a highest multiple of our desired range lower than the true range of the generator.
What if we want floating point/fixed point numbers? Just convert the integer result to that format somehow, for example ((float) random()) / ((float) RANDOM_MAX_VALUE) will produce a floating point number in range 0 to 1.
How to generate other probability distributions? Up until now we supposed a uniform probability distribution, i.e. the most random kind of generator that has an equal probability of generating any number. But sometimes we want a different distribution, i.e. we may want some numbers to be more likely to be generated than others. For this we normally start with the uniform generator and then convert the number into the new distribution. For that we may make use of the following:
{ If you want to look at some C code that tries to generate good pseudorandom numbers, take a look at gsl (GNU Scientific Library). ~drummyfish }
TODO: some algorithms from the gsl library described at https://www.gnu.org/software/gsl/doc/html/rng.html
This topic alone can be extremely complex, you could probably do a PhD on it, let's just do some overview for mere noobs like us.
Firstly you want your generator to be simply a good program in general, i.e. you want it to be as fast, small and as simple as possible while generating nice sequences. Consider that someone will want to use it to for example generate a white noise for a whole HD screen 60 times per second -- that may be something like 100 million numbers per second! We often judge generators by type and number of operations they need to generate the next number, as that will imply the speed -- as always, you generally want to avoid general division, branching, minimize multiplications and so on. Typically you'll probably want something like one multiplication and a few fast operations like an addition and modulo by power of two. That's basically what the congruential generators do. See also optimization.
However the core of a pseudorandom generator is the quality of the sequence itself, i.e. ensuring it really looks very random, that it has no patterns. To a noob this sounds easy, he thinks that if you just make some random shit with the numbers it's going to look random, he also thinks that the more things you do with the numbers the more random they'll look -- this is FALSE (typically if you just throw in more operations without thinking you'll make the sequence worse). It's not easy at all to make a random looking sequence of numbers! There is a danger in that with some effort you can make a sequence that will look random to you, but once you use the sequence to generate something -- for example some kind of noise -- you'll see there is actually some pattern, for example you'll see some straight lines in the noise etc. For some applications it may be sufficient to have a lower quality generator, but the danger lies in the cases in which you need a good generator and you think you have one while in fact you don't -- typically scientific simulation have to be extremely careful about this. For example if you're doing genetic programming and you need to somehow randomly pick organisms so as to make the evolution fair -- if you have a bad generator, your program won't work because it may secretly be not too random in its choices, it will be unfair -- in this case it will be VERY hard for you to find the cause of why your program doesn't work (in the worse case you'll think it works and will trust its results when in fact the results are bad). To avoid this trap you need to actually test the quality of your sequence (TBH if you want a really good generator you should definitely use something better than the mentioned congruential generator). Let's see some general stuff you can try (considering the base case of generating uniformly distributed numbers):
2^N steps and no sooner -- this will ensure not only the maximum period length, but also that the period length will be the same for every starting seed! That's because in this ideal case you simply have a single cycle over all the possible internal number values.
If an "intellectual work" (song, book, computer program, ...) is in the public domain (PD), it has no "owner", meaning no one has any exclusive "rights" (such as copyright or patent) over the work, no one can dictate how and by whom such work can be used and so anyone can basically do anything with such work (anything that's not otherwise illegal of course).
LRS highly supports public domain and recommends programmers and artists put their works in the public domain using waivers such as CC0 (this very wiki is of course released as such), possibly also WPPD etc.
Public domain is the ultimate form of freedom in the creative world. In public domain the creativity of people is not restricted. Anyone can study, remix, share and improve public domain works in any way, without a fear of being legally bullied by someone else.
The term "public domain" is sometimes used vaguely to mean anything under a free license, however this use is incorrect and greatly retarded. Public domain is NOT the same thing as free (as in freedom) software, free culture or freeware (gratis, free as in beer) software. The differences are these:
This is not a trivial question, firstly because the term public domain is not clearly defined: the definition varies by each country's laws, and secondly because it is non-trivial and sometimes very difficult to assess the legal status of a work.
Corporations and capitalism are highly hostile towards public domain and try to destroy it, make it effectively non-existing, as to eliminate "free" works competing with the consumerist creations of the industry. Over many years they have pushes towards creating laws that make it extremely difficult and rare for works to fall into public domain.
Sadly due to these shitty laws most works created in latest decades are NOT in the public domain because of the copyright cancer: copyright is granted automatically, without any registration or fee, to the author of any shitty artistic creation, and its term lasts mostly for the whole life of the author plus 70 years!* In some countries this is life + 100 years. In the US, copyright lasts 96 years from the publication of the work (every January 1st there is so called public domain day celebrating new works entering the US public domain). In some countries it is not even possible to legally waive (give up) one's copyright. And to make matters worse, copyright isn't the only possible restriction of an intellectual work, there are also patents, trademarks, personality rights and other kinds of intellectual property.
Another bad news is that works in a "weak" public domain, i.e. most recent PD works or works that entered PD by some obscure little law, may as well stop being PD by introducing some shitty retroactive law (which has happened). So one may not be feeling completely safe going crazy by utilizing some recent PD works.
We therefore devise the term safe/strong public domain. Under this we include works that are pretty safely PD more or less world-wide, even considering possible changes in laws etc. Let us include these works:
Creative commons has created a public domain mark that helps mark and find works that should be in a world-wide public domain (this is not a waiver though, it is basically only used as a metadata for very old works to be better searchable).
There are a number of places on the internet to look for public domain works, for a list see below.
Should you release you own works to the public domain? Definitely yes! In our opinion public domain is the only option as we deem any "intellectual property" immoral, however even if you disagree with us or feel reluctant about going "all in", you may want to release at least some of your works into public domain, if only out of spontaneous feel-good altruism, no longer caring about your old works, out of curiosity or even to make yourself a bit popular in the free culture community (thought this is a motivation we don't entirely embrace). Are you scared of doing it? It is natural, letting go of something you spent part of your life on can induce a bit of anxiety, but this is just a fear of the first step to the unknown, a fear almost entirely artificial, created by capitalist propaganda; making this decision will really most likely only have positive effects unless you actually had SERIOUS plans to make a business of your proprietary art. Practically the worst that can happen is that your work goes unnoticed and unappreciated. If you are still hesitant, try to go slowly, first release one thing, something small, and see what happens.
But isn't releasing a work into public domain dangerous? Doesn't that just invite someone to take the work and claim it as his own? This is a pretty common question so let's tackle it. Firstly know that releasing a work into public domain DOES NOT give others the right to claim it as their work -- it gives them the right to use that work in any way, even to make money (although it will be hard to make money solely by selling something that's already available for free), but someone claiming to have created a work he did not in fact create is simply plagiarism, lying and false claim of copyright, which is not only unethical and will hurt the reputation of the individual if it's proven (which can easily be done, e.g. by showing you released the work earlier through Internet Archive etc.), but may even be punishable by law (even though plagiarism is usually not a crime in itself, it may be deemed for example a fraud). Yes, some people may still attempt to do it (just like people practice piracy despite it being illegal), but please note they can just as easily do this even if the work isn't public domain -- they can simply (though illegally) take it and claim it as their own even if you keep your copyright on it. The only "protection" against this is to simply never release the work publicly at all, i.e. the fact that you make your work public domain doesn't make it more easy to be plagiarized. From this point of view it' actually probably much more "dangerous" to for example publish the work anonymously (even if you keep "all rights reserved"), i.e. concealing your real identity when publishing the work (to which you may be pushed by the privacy hysteria of today's culture), as this will make it impossible for you to later on prove it was you who made it; if someone takes the work and starts milking it, you cannot sue him as you can't prove you hold copyright on it and he may claim it was him who originally published it anonymously (well, it actually further depends on each country how anonymously published works are treated, but in general it will be more messy and the fact you can't prove your authorship stays).
{ I remember myself how anxious I was about making the decision to release all my work into public domain, despite knowing it was the right thing to do and that I wanted to do it. I felt emotional about giving away rights to art I put so much love and energy into, fearing the evil vultures of the Internet would immediately "steal" it all as soon as I release it. I overcame the fear and now, many years later, I can say that not once have I regretted it, literally not a single case of abuse of my work happened (that I know of anyway), despite some of it becoming kind of popular. I only received love of many people who found my work useful, and even received donations from people. I've seen others put my work to use, improve it, I get mail from people thanking me for I've done. Of course this all is not why I did it, but it's nice, I write about it to share a personal experience that will maybe give you the courage to do the right thing as well. ~drummyfish }
To create a public domain work you must ensure that after you release it, no one will hold exclusive intellectual property rights to it -- most notably we will be trying to remove copyright from the work (which arises automatically, last extremely long and is most annoying), but know that there are potentially also other rights to take into account, e.g. patents, trade marks, trade dress, personality rights, etc. (in usual cases you don't have to deal with these as they apply only to some things in some situations, but for things like program source code you may need to look into them). We will remove such rights with licenses or waivers, i.e. a legal text which we attach to our works and which says we just give up our rights. Sadly this is not trivial to do.
If you want to create a PD work, then generally in that work you must not reuse any non-public domain work. So, for example, you can NOT create a public domain fan fiction story about Harry Potter because Harry Potter and his universe is copyrighted (your fan fiction here would be so called derivative work or a copyrighted work). Similarly you can't just use randomly googled images in a game you created because the images are most likely copyrighted. Small and obscure exceptions (trivial bitmap fonts, freedom of panorama, ...) to this may exist in laws but it's never good to rely on such quirky laws (they may differ between countries etc.), it's best to keep it safe and simply avoid utilizing anything non-PD within your works. If you can, create everything yourself, that's the safest bet.
Note that even things such as music/sound samples, text fonts or paint brushes may sometimes be copyrighted. Just be careful, try to make everything from scratch -- yes, it sucks, because copyright sucks, but this is simply how we bypass it. Making everything yourself from the ground up also teaches you a lot and makes your art truly original, it's not a wasted time.
Also you must NOT use anything under fair use! Even though you could lawfully use someone else's copyrighted work under fair use, inclusion of such material would, by the fair use rules, limit what others would be able to do with your work, making it restricted and therefore not public domain. Example: you can probably write a noncommercial Harry Potter fan fiction and share it with friends on the internet because that's fair use, however this fan fiction can never be public domain because it can't e.g. be used commercially, that would no longer fall under fair use, i.e. there is a non-commercial-use-only restriction burdening your work. It doesn't even help if you get an explicit permission to use a copyrighted work in your work unless such permission grants all the right to everyone (not just your work). { I got a mascot removed from SuperTuxKart by this argument, mere author's permission to use his work isn't enough to make it free as in freedom. ~drummyfish }
Also do NOT USE AI, not even for routine tasks like upscaling and enhancements. NO JUST DO NOT. NO, your argument is invalid, just DO NOT USE IT. In theory it may be legit, but there's just massive doubt, uncertainty and legal mess. To name a few potential issues: AI may create a derivative work of something it has seen in its training dataset (which even if "open"-licensed still may contain material of non-free things that may be legal in the context of the dataset but not in the context of the generated result, e.g. "freedom of panorama"), the copyright status of AI works themselves is not as of yet clear and even once it's established, it may differ by country AND there is a danger of retroactive changes (once it becomes too easy to create PD works with AI capitalists can just push a law that will say AI can't be used for this because "economy" and yes, it may even be used retroactively, yes, they can do it, it already happened). Furthermore even if AI works are made legit, terms and condition of most usable AI software will still negate this (they already do, EVEN if you pay for it), it's not even clear if they can do this (or it may depend on territory and time) but it's a threat. Also AI is a soulless low quality crap, bloat and serves mostly capitalists to shit out massive quantities of cheap shit for consumerist games, we just don't need this. You may think "haha I'll create one trillion PD textures and post them to Opengameart and save the world" -- that's literally what everyone is doing right now, it's the worst kind of spam that is now just killing the site, please don't even think of this. Create something small but nice, something whose legitimacy as your own work that you give away can not be questioned.
So you can only use your own original creations and other public domain works within your PD work. Here you should highly prefer your own creations because that is legally the safest, no one can ever challenge your right to reuse your own creation, but there is a low but considerable chance that someone else's PD work isn't actually PD or will cease to be PD by some retroactive law change. So when it only takes a small effort to e.g. photograph your own textures for a game instead of using someone else's PD textures, choose to use your own.
{ NOTE: The above is kind of arguing for reinventing wheels which goes a little bit against our philosophy of remixing and information sharing, but we are forced to do this by the system. We are forced to reinvent wheels to ensure that users of our works can't be legally bullied. ~drummyfish }
In cases where you DO reuse other PD works, try to minimize their number and try to make sure they belong to the actual safe public domain (see above). This again minimizes legal risk and additionally makes it easy to document and prove the sources.
As a next step make sure you clearly document your work and the sources you use. This means you write down where all the works contained in your work come from, e.g. in your readme. Explicitly mention which things you have created yourself ("I, ..., have created everything myself except for X, Y and Z") and which things come from other people and where you have found them. It is great to also archive the proofs of the third party source being public domain (e.g. use the Internet Archive to snapshot the page with a PD texture you've found). For works that allow it (e.g. source code, text, websites, ...) it is good to use version control systems such as git that record WHAT, WHEN and by WHO was contributed. This can all help prove that your work is actually safe and/or remove contributions that caused some legal trouble.
If you collaborate with someone on the work, it must be clear that ALL contributors to the work follow what we describe here (e.g. that they all agree to the license/waiver you have chosen etc.). It is safer if there are fewer contributors as with more people involved the chance of someone starting to "make trouble" increases.
Finally you need to actually release your work into the public domain. Remember that you want to achieve a safe, world-wide public domain (so again you shouldn't try to rely on some weird/obscure laws of your own small country). It must be stressed that it is NOT enough to write "my work is public domain", this is simply legally insufficient (and in many countries you can't even put your work into public domain which is why you need a more sophisticated tool). You need to use a public domain waiver (similar to a license) which you just put alongside your work (e.g. into the LICENSE file), plus it is also good to explicitly write (e.g. in your readme) a sentence such as "I, ..., release this work into public domain under CC0 1.0 (link), public domain". Bear in mind that the WORDING may be very important here, so try to write this well: we mention the license name AND its version (CC0 1.0, it may even be better to fully state Creative Commons 1.0) as well as a link to its exact text and also mention the words public domain afterwards to make the intent of public domain yet clearer to any doubters. Here we used what's currently probably the best waiver you can use: Creative Commons Zero (CC0) -- this is what we recommend. However note that CC0 only waives copyright and not other things like trademarks or patents, so e.g. for software you might need to add an extra waiver of these things as well.
{ I personally use the following waiver IN ADDITION to CC0 with my software to attempt waiving of patents, trademarks etc. I made it by taking some standard waiver companies use to steal "rights" of their employees and modifying it to make it a public domain waiver. If you want to use it, make sure you mention it is an EXTRA, additional waiver alongside CC0. The waiver text follows. ~drummyfish
Each contributor to this work agrees that they waive any exclusive rights, including but not limited to copyright, patents, trademark, trade dress, industrial design, plant varieties and trade secrets, to any and all ideas, concepts, processes, discoveries, improvements and inventions conceived, discovered, made, designed, researched or developed by the contributor either solely or jointly with others, which relate to this work or result from this work. Should any waiver of such right be judged legally invalid or ineffective under applicable law, the contributor hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to this right. }
NOTE: You may be thinking it doesn't particularly matter whether you waive your rights properly and very clearly if you know you simply won't sue anyone, you may think it's enough to scribble down something like "do whatever you want with my creation". But you have to remember others, and even you yourself, can't be sure if you won't change your mind in the future. A clear waiver is a legal guarantee you provide to others, not just a vague promise of someone on the Internet, and this guarantee is very valuable, so valuable that whether someone uses your work or not will often come down to this. So waiving your "rights" properly may increase the popularity and reusability of your work almost as much as the quality of the work itself.
For an example of a project project properly released into public domain see the repository of our LRS game Anarch.
There are quite a few places on the Internet where you may find public domain works. But firstly let there be a warning: you always have to check the public domain status of works you find, it is extremely common for people on the Internet to not know what public domain is or how it works so you will find many false positives that are called public domain but are, in fact, not. This article should have given you a basic how-to on how to recognize and check public domain works. With this said, here is a list of some places to search (of course, this list will rot with time):
cat incategory:cc-zero. This site is quite reliable and serious about licensing, if you find a work marked as PD here, you can be reasonably sure this information is true.
Please kindly click random link.
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
Not to be confused with pseudorandomess.
Randomness means unpredictability, lack of patterns, and/or events without (apparent) cause. Random events can only be predicted imperfectly using probability because there is something present that's subject to chance, something we don't know; events may be random to us either because they are inherently random (i.e. they really have no cause, pattern etc.) or because we just lack knowledge, understanding or practical ability (e.g. enough computational power) to perfectly predict the events. Randomness is one of the most basic, yet also one of the most difficult (and fascinating) concepts to understand about our Universe -- it's a phenomenon of uttermost practical importance, we encounter it every second of our daily lives, but it's also of no lesser interest to science, philosophy, art and religion. Whole libraries could be filled just with books about this subject, here we will be able to only scratch the surface by taking a high altitude overview of randomness, mostly as related to programming and math. Randomness (and pseudorandomness) is one of the things that can bring a lot of fun into programming -- it's quite simple but very entertaining to create generators of various random things such as music, novels (see e.g. nanogenmo), pictures, randomly behaving bots and so on. Among the most commonly used sources of "true randomness" are dice throws, coin flips, cosmic background radiation noise, Brownian motion, measurements of quantum properties such as radioactive decay etc.
As with similarly wide spanning terms, the word randomness and random may be defined in different ways and change meaning slightly depending on context, for example sometimes we have to distinguish between "true" randomness, such as that we encounter in quantum mechanics or that present in nondeterministic mathematical models, and pseudorandomness (what as a programmer you'll be probably dealing with), i.e. imitating this true randomness with deterministic ("non-randomly behaving") systems, e.g. sequences of numbers that are difficult to compress. Other times we call random anything at all that just deviates from usual order, as in "someone started randomly spamming me in chat". Sometimes there are slight nuances in the meaning, for example by the word "random" we can mean "generated by a randomly behaving process", but also for example "data having statistical properties the same as if they were generated by a random process". Sometimes the distinctions don't matter too much, sometimes they do. Let's briefly review a few terms related to this topic:
Fun fact: "high quality" random number sequences have been published as large books, and not as a joke. A sequence whose "randomness" has been thoroughly checked and verified is much valued because certain tasks (typically e.g. Monte Carlo simulations) highly rely on randomness. A book called A Million Random Digits with 100,000 Normal Deviates published in 1955 is one example of such a book.
Keep in mind there are different "amounts" of randomness -- that is to say you should consider that probability distributions exist and that some processes may be random only a little. It is not like there are only completely predictable and completely unpredictable systems, oftentimes we just have some small elements of chance or can at least estimate which outcomes are more likely. We see absolute randomness (i.e. complete unpredictability) only with uniform probability distribution, i.e. in variables in which all outcomes are equally likely -- for example rolling a dice. However in real life variables some values are usually more likely than others -- e.g. with adult human male height values such as 175 cm will be much more common than 200 cm; great many real life values actually have normal distribution -- the one in which values around some center value are most common.
What do random numbers look like? This is a tricky question. Let's now consider uniform probability distribution, i.e. "absolute randomness". When we see sequences of numbers such as [1, 2, 3, 4, 5, 6, 7], [0, 0, 0, 0, 0, 0, 0, 0] or [9, 1, 4, 7, 8, 1, 5], which are "random" and which not? Intuitively we would say the first two are not random because there is a clear pattern, while the third one looks pretty random. However consider that under our assumption of uniform probability distribution all of these sequences are equally likely to occur! It is just that there are only very few sequences in which we recognize a common pattern compared to those that look to have no pattern, so we much more commonly see these sequences without a pattern coming out of random number generators and therefore we think the first two patterns are very unlikely to have come from a random source. Indeed they are, but the third, "random looking" sequence is equally unlikely (if you bet the numbers in lottery, you are still very unlikely to win), it just has great many weird looking siblings. You have to be careful, things around probability are great many times very unintuitive and tricky (see e.g. the famous Monty Hall problem). Humans are bad at creating "random" sequences, or perhaps said better: when you ask someone to come up with a sequence of "random" numbers, it will be a very predictable one, there are many famous demonstrations of this, humans for example tend to produce homogenous sequences of bits without longer streaks of 1s and 0s (and such sequences are quite unlikely to appear randomly). So never try to create your own pseudorandom sequence by randomly pressing numbers on the keyboard. The thing confusing to humans is that randomness is actually NOT a complete absence of patterns, we sometimes will spot familiar patterns in random sequences (for example hearing voices in white noise), but these patterns themselves emerge randomly, there is no way to predict WHICH pattern familiar to our brain will appear.
Of course we cannot say just from the sequence alone if it was generated randomly or not, the sequences above may have been generated by true randomness or by pseudorandom generator -- we even see this is sort of stupid to ask. We should rather think about what we actually mean by asking whether the sequence is "random" -- to get meaningful answers we have to specify this first. If we formulate the question precisely, we may get precise answers. Sometimes we are looking for lack of patterns -- this can be tested by programs that look for patterns, e.g. compression programs; number sequences that have regularities in them can be compressed well. We may examine the sequences entropy to say something about its "randomness". Mathematicians often like to ask "how likely is it that a sequence with these properties was generated by this model?", i.e. for example listening to signals from space and capturing some numeric sequence, we may compute its properties such as distribution of values in it and then we ask how likely is it that such sequence was generated by some natural source such exploding star or black hole? If we conclude this is very unlikely, we may say the signal was probably not generated randomly and may e.g. come from intelligent lifeforms.
TODO: moar
TODO
One of the most basic is the chi-squared test whose description can be found e.g. in the Art of Computer Programming book. TODO
{ The following is a method I came up with wrote about here (includes some code): https://codeberg.org/drummyfish/my_writings/src/branch/master/randomness.md, I haven't found what this is called, it probably already exists. If you know what this method is called, please send me a mail. ~drummyfish }
Cool randomness test: this test attempts to measure the unpredictability, the inability to predict what binary digit will follow. As an input to the test we suppose a binary sequence S of length N bits that's repeating forever (for example for N = 2 a possible sequence is 10 meaning we are really considering an infinite sequence 1010101010...). We suppose an observer knows the sequence and that it's repeating (consider he has for example been watching us broadcast it for a long time and he noticed we are just repeating the same sequence over and over), then we ask: if the observer is given a random (and randomly long) subsequence S2 of the main sequence S, what's the average probability he can correctly predict the bit that will follow? This average probability is our measured randomness r -- the lower the r, the "more random" the sequence S is according to this test. For different N there are different minimum possible values of r, it is for example not possible to achieve r < 0.7 for N = 3 etc. The following table shows this test's most random sequences for given N, along with their count and r.
| seq. len. | most random looking sequences | count | min. r |
|---|---|---|---|
| 1 | 0, 1 | 2 | 1.00 |
| 2 | 01, 10 | 2 | 0.50 |
| 3 | 001, 010, 011, 100, 101, 110 | 6 | ~0.72 |
| 4 | 0011, 0110, 1001, 1100 | 4 | ~0.78 |
| 5 | 00101, 01001, 01010, 01011, 01101, 10010, 10100, 10101, 10110, 11010 | 10 | ~0.82 |
| 6 | 000101, 001010, 010001, 010100, 010111, 011101, 100010, 101000, 101011, 101110, 110101, 111010 | 12 | ~0.86 |
| 7 | 0001001, 0010001, 0010010, 0100010, 0100100, 0110111, 0111011, 1000100, 1001000, 1011011, ... | 14 | ~0.88 |
| 8 | 00100101, 00101001, 01001001, 01001010, 01010010, 01011011, 01101011, 01101101, 10010010, ... | 16 | ~0.89 |
| 9 | 000010001, 000100001, 000100010, 001000010, 001000100, 010000100, 010001000, 011101111, ... | 18 | ~0.90 |
| 10 | 0010010101, 0010101001, 0100100101, 0100101010, 0101001001, 0101010010, 0101011011, ... | 20 | ~0.91 |
| 11 | 00010001001, 00010010001, 00100010001, 00100010010, 00100100010, 01000100010, 01000100100, ... | 22 | ~0.92 |
| 12 | 001010010101, 001010100101, 010010100101, 010010101001, 010100101001, 010100101010, ... | 24 | ~0.92 |
| 13 | 0010010100101, 0010100100101, 0010100101001, 0100100101001, 0100101001001, 0100101001010, ... | 26 | ~0.93 |
| ... | ... | ... | ... |
WORK IN PROGRESS { Also I'm not too good at statistics lol. ~drummyfish }
Here is a sequence of 1000 bits which we most definitely could consider truly random as it was generated by physical coin tosses:
{ The method I used to generate this: I took a plastic bowl and 10 coins, then for each round I threw the coins into the bowl, shook them (without looking, just in case), then rapidly turned it around and smashed it against the ground. I took the bowl up and wrote the ten generated bits by reading the coins kind of from "top left to bottom right" (heads being 1, tails 0). ~drummyfish }
00001110011101000000100001011101111101010011100011 01001101110100010011000101101001000010111111101110 10110110100010011011010001000111011010100100010011 11111000111011110111100001000000001101001101010000 11111111001000111100100011010110001011000001001000 10001010111110100111110010010101001101010000101101 10110000001101001010111100100100000110000000011000 11000001001111000011011101111110101101111011110111 11010001100100100110001111000111111001101111010010 10001001001010111000010101000100000111010110011000 00001010011100000110011010110101011100101110110010 01010010101111101000000110100011011101100100101001 00101101100100100101101100111101001101001110111100 11001001100110001110000000110000010101000101000100 00110111000100001100111000111100011010111100011011 11101111100010111000111001010110011001000011101000 01001111100101001100011100001111100011111101110101 01000101101100010000010110110000001101001100100110 11101000010101101111100111011011010100110011110000 10111100010100000101111001111011010110111000010101
Let's now take a look at how random the sequence looks, i.e. basically how likely it is that by generating random numbers by tossing a coin will give us a sequence with statistical properties (such as the ratio of 1s and 0s) that our obtained sequence has.
There are 494 1s and 506 0s, i.e. the ratio is approximately 0.976, deviating from 1.0 (the value that infinitely many coin tosses should converge to) by only 0.024. We can use the binomial distribution to calculate the "rarity" of getting this deviation or higher one; here we get about 0.728, i.e. a pretty high probability, meaning that if we perform 1000 coin tosses like the one we did, we may expect to get the deviation we got or higher in more than 70% of cases (if on the other hand we only got e.g. 460 1s, this probability would be only 0.005, suggesting the coins we used weren't fair). If we take a look at how the ratio (rounded to two fractional digits) evolves after each round of performing additional 10 coin tosses, we see it gets pretty close to 1 after only about 60 tosses and stabilizes quite nicely after about 100 tosses: 0.67, 0.54, 0.67, 0.90, 0.92, 1.00, 0.94, 0.90, 0.88, 1.00, 1.04, 1.03, 0.97, 1.00, 0.97, 1.03, 1.10, 1.02, 0.98, 0.96, 1.02, 1.02, 1.02, 1.00, 0.95, 0.95, 0.99, 0.99, 0.99, 0.97, 0.95, 0.95, 0.96, 0.93, 0.90, 0.88, 0.90, 0.93, 0.95, 0.98, 0.98, 0.97, 0.97, 0.99, 1.00, 0.98, 0.98, 0.98, 0.97, 0.96, 0.95, 0.94, 0.95, 0.95, 0.96, 0.95, 0.96, 0.95, 0.96, 0.95, 0.96, 0.95, 0.96, 0.96, 0.97, 0.97, 0.97, 0.95, 0.94, 0.93, 0.93, 0.93, 0.94, 0.94, 0.94, 0.96, 0.95, 0.96, 0.96, 0.95, 0.96, 0.95, 0.95, 0.96, 0.97, 0.97, 0.96, 0.96, 0.95, 0.95, 0.95, 0.96, 0.97, 0.97, 0.97, 0.97, 0.96, 0.97, 0.98, 0.98.
Next we'll take a look at streaks, i.e. uninterrupted runs of the same value (0 or 1). Here it is (0s, 1s and total are total streak counts, 0s first and 1s first are the positions of first streak occurrence):
| streak len. | 0s | 0s first | 1s | 1s first | total |
|---|---|---|---|---|---|
| 1 | 122 | 12 | 126 | 13 | 247 |
| 2 | 62 | 7 | 65 | 48 | 127 |
| 3 | 34 | 45 | 27 | 4 | 61 |
| 4 | 16 | 0 | 17 | 162 | 33 |
| 5 | 8 | 238 | 10 | 31 | 18 |
| 6 | 4 | 14 | 3 | 375 | 7 |
| 7 | 2 | 497 | 2 | 88 | 4 |
| 8 | 2 | 176 | 1 | 200 | 3 |
At first glance all looks fine, the streak counts are very similar for 1s and 0s and the counts smoothly decrease with streak length, we see no jumps or other red flags in the distribution. More rigorously we should calculate expected values and compare them with what we've got of course, but we'll now suffice with this simple check: supposedly the probabilities of seeing a streak of at least 8 and 9 1s in 1000 tosses are 0.86 and 0.62 respectively, which seems to check out (we've hit the very probably 0.86 case and then fell into the slightly less but still very plausible case of not producing a streak of 9, with probability 0.38).
{ The total streak count seems suspiciously close to 2^(9-n), there's probably a formula but I didn't have time to check it now, TODO: investigate later. ~drummyfish }
Let's try the chi-squared test (the kind of basic "randomness" test): D = (494 - 500)^2 / 500 + (506 - 500)^2 / 500 = 0.144; now in the table for the chi square distribution for 1 degree of freedom (i.e. two categories, 0 and 1, minus one) we see this value of D falls somewhere around 30%, which is not super low but not very high either, so we can see the test doesn't invalidate the hypothesis that we got numbers from a uniform random number generator. { I did this according to Knuth's Art of Computer Programming where he performed a test with dice and arrived at a number between 25% and 50% which he interpreted in the same way. For a scientific paper such confidence would of course be unacceptable because there we try to "prove" the validity of our hypothesis. Here we put much lower confidence level as we're only trying not fail the test. To get a better confidence we'd probably have to perform many more than 1000 tosses. ~drummyfish }
We can try to convert this to a sequence of integers of different binary sizes and just "intuitively" see if the sequences still looks random, i.e. if there are no patterns such as e.g. the numbers only being odd or the histograms of the sequences being too unbalanced, we could also possibly repeat the chi-squared test etc.
The sequence as 100 10 bit integers (numbers from 0 to 1023) is:
57 832 535 501 227 311 275 90 267 1006 730 155 273 874 275 995 759 528 52 848 1020 572 565 556 72 555 935 805 309 45 704 842 969 24 24 772 963 479 695 759 838 294 241 998 978 548 696 337 29 408 41 774 429 370 946 330 1000 104 886 297 182 293 719 308 956 806 398 12 84 324 220 268 911 107 795 958 184 917 612 232 318 332 451 911 885 278 784 364 52 806 929 367 630 851 240 753 261 926 859 533
As 200 5 bit integers (numbers from 0 to 31):
1 25 26 0 16 23 15 21 7 3 9 23 8 19 2 26 8 11 31 14 22 26 4 27 8 17 27 10 8 19 31 3 23 23 16 16 1 20 26 16 31 28 17 28 17 21 17 12 2 8 17 11 29 7 25 5 9 21 1 13 22 0 26 10 30 9 0 24 0 24 24 4 30 3 14 31 21 23 23 23 26 6 9 6 7 17 31 6 30 18 17 4 21 24 10 17 0 29 12 24 1 9 24 6 13 13 11 18 29 18 10 10 31 8 3 8 27 22 9 9 5 22 9 5 22 15 9 20 29 28 25 6 12 14 0 12 2 20 10 4 6 28 8 12 28 15 3 11 24 27 29 30 5 24 28 21 19 4 7 8 9 30 10 12 14 3 28 15 27 21 8 22 24 16 11 12 1 20 25 6 29 1 11 15 19 22 26 19 7 16 23 17 8 5 28 30 26 27 16 21
Which has the following histogram:
number: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 count: 6 6 3 6 5 5 7 5 11 10 7 6 7 3 4 5 number: 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 count: 7 9 3 5 4 8 7 8 9 4 8 6 8 6 6 6
And as 250 4 bit integers (numbers from 0 to 15):
0 14 7 4 0 8 5 13 15 5 3 8 13 3 7 4 4 12 5 10 4 2 15 14 14 11 6 8 9 11 4 4 7 6 10 4 4 15 14 3 11 13 14 1 0 0 13 3 5 0 15 15 2 3 12 8 13 6 2 12 1 2 2 2 11 14 9 15 2 5 4 13 4 2 13 11 0 3 4 10 15 2 4 1 8 0 6 3 0 4 15 0 13 13 15 10 13 14 15 7 13 1 9 2 6 3 12 7 14 6 15 4 10 2 4 10 14 1 5 1 0 7 5 9 8 0 10 7 0 6 6 11 5 7 2 14 12 9 4 10 15 10 0 6 8 13 13 9 2 9 2 13 9 2 5 11 3 13 3 4 14 15 3 2 6 6 3 8 0 12 1 5 1 4 4 3 7 1 0 12 14 3 12 6 11 12 6 15 11 14 2 14 3 9 5 9 9 0 14 8 4 15 9 4 12 7 0 15 8 15 13 13 5 1 6 12 4 1 6 12 0 13 3 2 6 14 8 5 6 15 9 13 11 5 3 3 12 2 15 1 4 1 7 9 14 13 6 14 1 5
This has the following histogram:
number: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 count: 18 14 19 18 23 15 18 11 11 14 9 10 13 20 18 19
Another way to test data randomness may be by trying to compress it, since compression is basically based on removing regularities, redundancy, leaving only randomness. A compression algorithm exploits correlations in input data and removes that which can later be reasoned out from what's left, but with a completely random data nothing should be correlated, it shouldn't be possible to reason out parts of such data from other parts of that data, hence compression can remove nothing and it shouldn't generally be possible to compress completely random data (though of course there exists a non-zero probability that in rare cases random data will have regular structure and we will be able to compress it). Let us try to perform this test with the lz4 compression utility -- we convert our 1000 random bits to 125 random bytes and try to compress them. Then we will try to compress another sequence of 125 bytes, this time a non-random one -- a repeated alphabet in ASCII (abcdefghijklmnopqrstuvwxyzabcdef...). Here are the results:
| sequence (125 bytes) | compressed size |
|---|---|
| our random bits | 144 (115.20%) |
abcdef... | 56 (44.80%) |
We see that while the algorithm was able to compress the non-random sequence to less than a half of the original size, it wasn't able to compress our data, it actually made it bigger! This suggests the data is truly random. Of course it would be good to test multiple compression algorithms and see if any one of them finds some regularity in the data, but the general idea has been presented.
Raycastlib (RCL) is a public domain (CC0) LRS C library for advanced 2D raycasting, i.e. "2.5D/pseudo3D" rendering. It was made by drummyfish, initially as an experiment for Pokitto -- later he utilized the library in his game Anarch. It is in spirit similar to his other LRS libraries such as small3dlib and tinyphysicsengine; just as those raycastlib is kept extremely simple, it is written in pure C99, with zero dependencies (not even standard library), it's written as a single file single header library, using no floating point and tested to run interactively even on very weak devices (simplified version was made run on Arduboy with some 2 KiB of RAM). Two rendering algorithms are provided to choose from: simple (only same height floor and ceiling, allowing textured floor and ceiling) and complex (allowing variable floor and ceiling, without textured floors and ceilings). Per rendered frame both algorithms always draw every screen pixels exactly once, without any overdraw and holes, which is very advantageous and elegant; the simple algorithm additionally also guarantees the pixels to be drawn in exact same linear order every time. It is very flexible thanks to use of callbacks for communication, allowing e.g. programming arbitrary "shader" code to implement all kinds of effects the user desires or using procedurally generated environments without having to store any data. The library implements advanced features such as floor and ceiling with different heights, textured floor, opening door, simple collision detection etc. It is written in just a bit over 2000 lines of code.
The repository is available at https://git.coom.tech/drummyfish/raycastlib. The project got 45 stars on gitlab before being banned for author's political opinions.
................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ...........XXXXXXXXXXXX/..........XXXXXXXXXXXXXXXXXXXXXX.......................o ...........XXXXXXXXXXXX////.......XXXXXXXXXXXXXXXXXXXXXX......................oo XXXXXXXXXXXXXXXXXXXXXXX//////.....XXXXXXXXXXXXXXXXXXXXXX...............ooooooooo XXXXXXXXXXXXXXXXXXXXXXX/////////..XXXXXXXXXXXXXXXXXXXXXX........oooooooooooooooo XXXXXXXXXXXXXXXXXXXXXXX//////////.XXXXXXXXXXXXXXXXXXXXXXXXXXXooooooooooooooooooo XXXXXXXXXXXXXXXXXXXXXXX//////////XXXXXXXXXXXXXXXXXXXXXXXXXXXXooooooooooooooooooo XXXXXXXXXXXXXXXXXXXXXXX//////////.XXXXXXXXXXXXXXXXXXXXXXXXXXXooooooooooooooooooo XXXXXXXXXXXXXXXXXXXXXXX/////////..XXXXXXXXXXXXXXXXXXXXXX........oooooooooooooooo XXXXXXXXXXXXXXXXXXXXXXX//////.....XXXXXXXXXXXXXXXXXXXXXX...............ooooooooo ...........XXXXXXXXXXXX////.......XXXXXXXXXXXXXXXXXXXXXX......................oo ...........XXXXXXXXXXXX/..........XXXXXXXXXXXXXXXXXXXXXX.......................o ................................................................................ ................................................................................ ................................................................................ ................................................................................
Simple rendering made with raycastlib.
{ December 2025: someone made a quite impressive "AI programmed" game with raycastlib and sent it to me over email. It was a maze game with bytebeat music, enemies and all together a nice feel. Allegedly it was made in 7 hours with some sort of "AI IDE" by iteratively telling the AI (as I understood it, but I don't know a lot about this) "what to do", which features to add, which bugs to fix and so on. It compiled and ran quickly and without issues, even using an "Anarch"-like compiling shell script, which stunned me -- AI can already program in this style After a very brief overview of the code I found it's rather messy, not just in formatting but the overall structure and architecture of the code, plus some parts of the code looked suspiciously close (almost like a copy-paste) of code in Anarch -- overall it's nowhere near a code written by a skilled C programmer yet, HOWEVER I was still very much impressed and quite "positively amazed" by the fact that this "AI" can even use my library which is not among mainstream ones like SDL and which isn't all together that much documented and traditional in how it's supposed to be used. The human author that used the AI was also very young and that made it even more impressive. In summary at this stage this "AI programming" is unexpectedly advanced but still not beating a skilled human, although this is most definitely going to change in a year or three or five. It can very much be used for C programming now but it's going to produce ugly, inefficient and buggy stuff, i.e. it can already replace most average programmers. ~drummyfish }
See recursion.
Recursion (from Latin recursio, "running back") in general is a situation in which a definition refers to itself; for example the definition of a human's ancestor as "the human's parents and the ancestors of his parents" (fractals are also very nice example of what a simple recursive definition can achieve). In programming recursion denotes a function that calls itself; this is the meaning we'll assume in this article unless noted otherwise.
{ Perhaps an analogy to this kind of recursion may be an "Inception"-style multi level dreams: imagine having a dream in a dream in a dream ... and so on -- and then at one point you start waking up, always getting back to where you were in each of the dreams, and so on until you completely wake up. --drummyfish }
Fun piece of trivia: geography knows the phenomenon of "recursive islands and lakes" -- islands that appear in lakes that appear on islands that appear in lakes etc. Wikipedia currently lists Lake Yathkyed in Canada as the "deepest" recursion of this type, having an island in lake on island in lake on island in lake.
We subdivide recursion to a direct and indirect. In direct recursion the function calls itself directly, in indirect function A calls a function B which ends up (even possibly by calling some more functions) calling A again. Indirect recursion is tricky because it may appear by mistake and cause a bug (which is nevertheless easily noticed as the program will mostly run out of memory and crash).
When a function calls itself, it starts "diving" deeper and deeper and in most situations we want this to stop at some point, so in most cases a recursion has to contain a terminating condition. Without this condition the recursion will keep recurring and end up in an equivalent of an infinite loop (which in case of recursion will however crash the program with a stack overflow exception). Let's see this on perhaps the most typical example of using recursion, a factorial function:
unsigned int factorial(unsigned int x)
{
if (x > 1)
return x * factorial(x - 1); // recursive call
else
return 1; // terminating condition
}
See that as long as x > 1, recursive calls are being made; with each the x is decremented so that inevitably x will at one point come to equal 1. Then the else branch of the condition will be taken -- the terminating condition has been met -- and in this branch no further recursive call is made, i.e. the recursion is stopped here and the code starts to descend from the recursion. The following diagram show graphically computation of factorial(4):
factorial(4) = 4 * 6 = 24
| ^
| | return
| '------------.
| call |
'-----> factorial(3) = 3 * 2 = 6
| ^
| | return
| '------------.
| call |
'-----> factorial(2) = 2 * 1 = 2
| ^
| | return
| '-----.
| call |
'------> factorial(1) = 1 <-- end condition met
Note that even in computing we can use an infinite recursion sometimes. For example in Hashell it is possible to define infinite data structures with a recursive definition; however this kind of recursion is intentionally allowed, it is treated as a mathematical definition and with correct use it won't crash the program.
Every recursion can be replaced by iteration and vice versa (iteration meaning a loop such as while) -- to get rid of recursion it is always possible to use a custom stack to which we'll be saving our state and thanks to which we'll be able to make the recursive "dives". Purely functional languages for example do not have loops at all and handle repetition solely by recursion. This means that you, a programmer, always have a choice between recursion and iteration, and here you should know that recursion is typically slower than iteration. This is because recursion has a lot of overhead: remember that every level of recursion is a function call that involves things such as pushing and popping values on stack, handling return addresses etc. The usual advice is therefore to prefer iteration, even though recursion can sometimes be more elegant/simple and if you don't mind the overhead, it's not necessarily wrong to go for it (see also optimization and the evil of trying to optimize your program in wrong places). Getting rid of a simple recursion (single direct recursive call) is usually easy, it only gets more complicated e.g. in case of multiple recursion when the function makes more than one call to itself (for example in case of quicksort), and here we usually stick with recursive implementation for its superior elegance. In the above example of factorial we only have one recurring branch, so it's much better to implement the function with iteration:
unsigned int factorial(unsigned int x)
{
unsigned int result = 1;
while (x > 1)
{
result *= x;
x--;
}
return result;
}
Printing string backwards also exemplifies elegant recursion:
#include <stdio.h>
void readAndPrintBackwards(void)
{
int c = getchar();
if (c != EOF)
{
readAndPrintBackwards();
putchar(c);
}
}
int main(void)
{
readAndPrintBackwards();
putchar('\n');
return 0;
}
The program reads one character in each call of the function and holds its printing for when we're emerging back from the recursion dive. The terminating condition here the check for end of the string (EOF). You can test this for program by compiling it and passing it a string, e.g. echo "catdog" | ./program which should result in printing godtac. In comun the same program would be written as:
readAndPrintBackwards:
<-
<? ?
readAndPrintBackwards
.
->
.
readAndPrintBackwards
Some problems, for example Ackermann function, quick sort, tree traversals or the mentioned factorial are said to be "recursive" because they are just most elegantly defined and/or solved with recursion, but as we've seen, there is no problem that would inherently require recursive function calls. There may exist Turing complete languages without recursion that can still solve all problems that any other language can.
How do computers practically make recursion happen? Basically they use a stack to remember states (such as values of local variables and return addresses) on each level of the recursive dive -- each such state is captured by so called stack frame. In programming languages that support recursive function calls this is hidden behind the curtains in the form of so called call stack. This is why an infinite recursion causes stack overflow whereas infinite loop doesn't -- each recursive call creates a new stack frame in the call stack and at one point the stack overflows.
Another relevant type of recursion is tail recursion that occurs when the recursive call in a function is the very last command. It is utilized in functional languages that use recursion instead of loops. This kind of recursion can be optimized by the compiler into basically the same code a loop would produce, so that e.g. stack won't grow tremendously.
Mathematical recursive functions find use in computability theory where they help us (similarly to e.g. Turing machines) define classes of functions (such as primitive recursive and partial recursive) by how "computationally strong" of a computer we need to compute them.
Regular expression (shortened regex or regexp) is a kind of mathematical expression, plentifully used in programming, that defines simple patterns in strings of characters (usually text). Regular expressions are typically used for searching patterns (i.e. not just exact matches but rather sequences of characters which follow some rules, e.g. numeric values or web URLs), substitutions (replacement) of such patterns, describing syntax of computer languages, their parsing etc. (though more creative uses aren't out of question either, e.g. generating random strings). Regular expression is itself a string of symbols which however describes potentially many (even infinitely many) other strings thanks to containing special symbols that may stand for repetition, alternative etc. For example a.*.b is a regular expression describing a string that starts with letter a, which is followed by a sequence of at least one character and then ends with b (so e.g. aab, abbbb, acaccb etc.).
WATCH OUT: be careful not to confuse regular expressions with Unix wildcards used in file names (e.g. sourse/*.c is a wildcard, not a regexp).
{ A popular online tool for playing around with regular expressions is https://regexr.com/, though it requires JS and is bloated; if you want to stay with Unix, just grep (possibly with -o to see just the matched string). ~drummyfish }
Regular expressions are encountered in many Unix tools, programming languages, editors etc. Especially worthy of mention are grep (searches for patterns in files), sed (text processor, often used for search and replacement of patterns), awk, Perl, Vim etc.
From the viewpoint of theoretical computer science and formal languages regular expressions are computationally weak, they are equivalent to the weakest models of computation such as regular grammars or finite state machines (both deterministic and nondeterministic) -- in fact regular expressions are often implemented as finite state machines. This means that regular expressions can NOT describe any possible pattern (for example they can't capture a math expression with nested brackets), only relatively simple ones; however it turns out that very many commonly encountered patterns are simple enough to be described this way, so we have a good enough tool. The advantage of regular expressions is exactly that they are simple, yet very often sufficient.
Are there yet simpler pattern describers than regular expressions? Yes, of course, the simplest example is just a string directly describing the pattern, e.g. "abc" matching exactly just the string "abc" -- this is called a fixed string. Next we can think of case-insensitive pattern, so "abc" would match "abc", "ABC", "AbC" etc. Notable subclass of regular expressions are so called star-free languages/expressions which are regular expressions without the star (repetition) operator. Star-free expressions can be used as a simpler variant to regular expressions, they may still describe many patterns and are easier to implement.
OK, let's now dive into how exactly regular expressions work, shall we? Imagine regexp as an extension of a fixed string pattern (a string describing exactly itself, i.e. "abc" describes just the string "abc"). The extension is in giving certain characters a special meaning -- the most common are . (dot) and * (asterisk). Dot means "any character is allowed here", so "a.c" will describe strings "aac", "abc", "acc" etc. Asterisk means "the previous character repeated any number of times (even zero)", so "abc" describes strings "ab", "abc", "abcc", "abccc" etc. If we want a regex to contain any special character as such, without its special meaning, we have to escape it -- for example "a.c" will describe just a string "a.c". This is a super swift high altitude introduction, more detail will follow.
There exist different standards and de-facto standards for regular expressions, some using different symbols, some having extra syntactic sugar (which however usually only make the syntax more comfortable, NOT more computationally powerful) and features (typically e.g. so called capture groups that allow to extract specific subparts of given matched pattern). There are cases where a feature makes regexes more computationally powerful, namely the backreference \n present in extended regular expressions (source: Backreferences in practical regular expressions, 2020). Most relevant standards are probably Posix and Perl (with specific implementations sometimes adding their own flavor, e.g. GNU, Vim etc.): Posix specifies basic and extended regular expression (extended usually turned on with the -E CLI flag). The following table sums up the most common constructs used in regular expressions:
| construct | matches | availability | example |
|---|---|---|---|
| char | this exact character | everywhere | a matches a |
. | any single character | everywhere | . matches a, b, 1 etc. |
expr* | any number (even 0) of repeating expr | everywhere | a* matches empty, a, aa, aaa, ... |
^ | start of expression (usually start of line) | everywhere | ^a matches a at the start of line |
$ | end of expression (usually end of line) | everywhere | a$ matches a at the end of line |
expr+ | matches 1 or more repeating expr | escape (\+) in basic | a+ matches a, aa, aaa, ... |
expr? | matches 0 or 1 expr | escape (\?) in basic | a? matches either empty or a |
[S] | matches anything character from set S | everywhere | [abc] matches a, b or c |
(expr) | marks group (for capt. groups etc.) | escape (\(, \)) in basic | a(bc)d matches abcd with group bc |
[A-B] | like [ ] but specifies a range | everywhere | [3-5] matches 3, 4 and 5 |
[^S] | matches any char. NOT from set S | everywhere | [^abc] matches d, e, A, 1 etc. |
{M,N} | M to N repetitions of expr | escape (\{, \}) in basic | a{2,4} matches aa, aaa, aaaa |
| e1<code>|</code>e2 | e1 or e2 | escape in basic | <code>ab|cd</code> match. ab or cd |
\n | backref., nth matched group (starts with 1) | extended only | (..).*\1 matches e.g. ABcdefAB |
[:alpha:] | alphabetic, a to z, A to Z | Posix (GNU has [[ ]]) | [:alpha:]* matches e.g. abcDEF |
[:alnum:] | same as above | ||
[:digit:] | same as above | ||
[:blank:] | same as above | ||
[:lower:] | same as above | ||
[:space:] | same as above | ||
\w | like [:alnum:] plus also _ char. | Perl | |
\d | digit, 0 to 9 | Perl | |
\s | like [:space:] | Perl |
Note on case-sensitivity: regular expressions can be case-insensitive, but besides special character classes (such as [:alnum:]) there isn't a widely standardized way to express case sensitivity inside the regular expression itself, it's usually done by passing a flag (such as -i) to the program that's using the expression. But there are exceptions, for example in vim adding \c anywhere in a regular expression makes it case-insensitive.
Here we'll demonstrate some practical uses of regular expressions. Most common Unix tools associated with regular expressions are probably grep (for searching) and sed (for replacing).
The most basic use case is you just wanting to search for some pattern in a file, i.e. for example you are looking for all IP addresses in a file, for a certain exact word inside source code comment etc.
The following uses grep to find and count all occurrences of the word capitalism or capitalist (disregarding case with the -i flag) in a plain text version of this wiki and passes them to be counted with wc.
`grep -i -o "capitalis[mt]" ~/Downloads/lrs_wiki.txt | wc -l
We find out there are 829 such occurrences.
Of course, quite frequently you may want to see the lines that match along with files and line numbers, try also e.g. grep -m 10 -H -n "Jesus" ~/Downloads/lrs_wiki.txt.
Now let's search for things that suck with (-o prints out just the matches instead of whole line, -m 10 limits the output to 10 results at most):
grep -o -m 10 "[^ ]* \(sucks\|is shit\)" ~/Downloads/lrs_wiki.txt
Currently we get the following output:
body sucks OS sucks everything sucks Everything is shit language sucks it sucks D&D sucks writing sucks Fediverse sucks This sucks
Now let's try replacing stuff with sed -- this is done with a very common format (which you should remember as it's often used in common speech) s/PATTERN/REPLACE/g where PATTERN is the regular expression to match, REPLACE is a string with which to replace the pattern (s stands for substitute and g for global, i.e. "replace all"). Let's say we are retarded and obsessed with muh privacy and want to censor all names in a portion of the wiki we want to print, so we'll just replace all words composed of letters that start with uppercase letter (and continue with lowercase letters) -- this will also censor other words than names but let's keep it simple for now. The command may look something like:
cat ~/Downloads/lrs_wiki.txt | tail -n +5003 | head -n 10 | sed "s/[A-Z][a-z]\+/<BEEP>/g"
Here we may get e.g.:
they typically have a personal and not easy to describe faith. [19]<BEEP> was a <BEEP>. [20]<BEEP> often used the word "[21]<BEEP>" instead of "nature" or "universe"; even though he said he didn't believe in the traditional personal <BEEP>, 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. [22]<BEEP> <BEEP> said he was "deeply religious, though not in the orthodox sense". <BEEP> are also very hardcore religious people such as [23]<BEEP> <BEEP>, the inventor of [24]<BEEP> language, who even planned to be a <BEEP> missionary. <BEEP> "true atheists" are mostly second grade "scientists" who make career out of the
A more advanced feature is what we call capture groups that allow us to reuse parts of the matched pattern in the replacement string -- this is needed in some cases, for example if you just want to insert some extra characters in the pattern. Capture groups are parts of the pattern inside brackets (( and ) which sometimes have to be escaped to \( and \)); in the replacement string we then reference them with \1 (first group), \2 (second group) etc. Let's demonstrate this on the following example that will highlight all four letter words:
cat ~/Downloads/lrs_wiki.txt | tail -n +8080 | head -n 7 | sed "s/ \([^ ]\)\([^ ]\)\([^ ]\)\([^ ]\) / \!\!\!\1-\2-\3-FUCKING-\4\!\!\! /g"
The result may look something like this:
Bootstrapping as a general principle can aid us in creation of extremely !!!f-r-e-FUCKING-e!!! technology by greatly minimizing all its [7]dependencies, we are able to create a small amount of !!!c-o-d-FUCKING-e!!! that !!!w-i-l-FUCKING-l!!! self-establish our whole computing environment !!!w-i-t-FUCKING-h!!! only !!!v-e-r-FUCKING-y!!! small effort during the process. The topic mostly revolves around designing [8]programming language [9]compilers, but in general we may be talking about bootstrapping whole computing environments, operating systems etc.
Now a pretty rare use case is generating random patterns -- we can imagine we have a regular expression describing for example a valid username in a game and for some reason we want to generate 1000 random strings that match this pattern (e.g. for bots). Now going into depth on this topic could take a long time because e.g. considering probability distributions we may get into some mathematical rabbit holes (considering that for example the regex .* matches an arbitrarily long string, what will be the average length of a string randomly generated by this pattern? 10? 1000? 1 billion?). Anyway let's leave this aside -- if we do, there is actually a quite simple and natural way of generating random patterns from regular expressions. We can convert the regexp into nondeterministic finite automaton, the make a random traverse of the graph and generate the string along the way. There don't even seem to be many Unix tools for doing this -- at the time of writing this one of the simplest way seems to be with Perl and one of its libraries, which currently still has some great limitations (no groups, no special characters in square brackets, ...), but it's better than nothing. The command we'll be using is:
perl -e "use String::Random; for (1..20) { print String::Random->new->randregex('REGEX') . \"\n\"; }" 2>/dev/null
Here are some strings generated with different REGEXes:
....*: \n\"; }", /dB|^hRR/3za~, ![5q-%ONK, "oJT.UzSa}0, t"}Yq]sWZjIv, Fq<xs~_e, H=5yt9q<>29XW, <EoVf)ORH{m, ...
[A-Z][a-z]{3,8}: Ponic, Xwawo, Hgrtky, Brmcitpsw, Qrogdze, Olhyb, Gqeelz, Igppehljz, Azrdava, ...
[:;=8B][-o]?[)({}/|PS]: ;o}, :-), ;(, B(, 8o), =/, :o|, =}, =-(, ...
[lL][oue]+lz?: Loeeolz, Luel, luuuolz, lol, Leelz, Leoeuoeoueulz, luueeoolz, ...
Let's now try to program a very simple regular expression in C. You can do this in quite fancy ways, serious regex libraries will typically let you specify arbitrary regular expression with a string at runtime (for example char *myRegex = "(abc|ABC).*d+";), then compile it to some fast, efficient representation like the mentioned state machine and use that for matching and replacing patterns. We'll do nothing like that here as that's too complex, we will simply make a program that has one hard wired regular expression and it will just say if given input string matches or not. Let's consider the following regular expression:
(<[^<>]*>|[^<>]*)*
It describes an "XML"-like text; the text can contain tags that start with < and end with >, but there mustn't e.g. be a tag inside another tag. For example <hello> what <world> will match, but hello > world << bruh won't match. OK, so the first thing to do is to convert the regular expression to a finite state automaton -- this can be done intuitively but there is also an exact algorithm that can do this with any regular expression (look it up if you need it). Our automaton will look like this:
.---. .---.
| | else | | else
____V___|____ '>' ____V___|___
| (accept) |<------| |
start --->| outside_tag |------>| inside_tag |
|_____________| '<' |____________|
| |
| '>' '<' |
__V___ |
.---| | |
any | | fail |<------------'
'-->|______|
Here we start in the outside_tag state and move between states depending on what characters we read from the input string we are analyzing (indicated next to the arrows). If we end up in the outside_tag state state again (marked as accepting state) when all is read, the input string matched the regular expression, otherwise it didn't. We'll translate this automaton to a C program:
#include <stdio.h>
#define STATE_OUTSIDE_TAG 0
#define STATE_INSIDE_TAG 1
#define STATE_FAIL 2
int main(void)
{
int state = STATE_OUTSIDE_TAG;
while (1)
{
int c = getchar();
if (c == EOF)
break;
switch (state)
{
case STATE_OUTSIDE_TAG:
if (c == '<')
state = STATE_INSIDE_TAG;
else if (c == '>')
state = STATE_FAIL;
break;
case STATE_INSIDE_TAG:
if (c == '>')
state = STATE_OUTSIDE_TAG;
else if (c == '<')
state = STATE_FAIL;
break;
case STATE_FAIL:
break;
}
}
puts(state == STATE_OUTSIDE_TAG ? "matches!" : "string didn't match :(");
return 0;
}
Just compile this and pass a string to the standard input (e.g. echo "<testing> string" | ./program), it will write out if it matches or not.
Maybe it seems a bit overcomplicated -- you could say you could program the above even without regular expressions and state machines. That's true, however imagine dealing with a more complex regex, one that matches a quite complex real world file format. Consider that in HTML for example there are pair tags, non-pair tags, attributes inside tags, entities, comments and many more things, so here you'd have great difficulties creating such parser intuitively -- the approach we have shown can be completely automated and will work as long as you can describe the format with regular expression.
TODO: structural regexps, regexes in some langs. like Python
RGB332 is a general 256 color palette that encodes one color with 1 byte (i.e. 8 bits): 3 bits (highest) for red, 3 bits for green and 2 bits (lowest) for blue (as human eye is least sensitive to blue we choose to allocate fewest bits to blue). RGB332 is an implicit palette -- it doesn't have to be stored in memory (though doing so also has justifications) because the color index itself determines the color and vice versa. Compared to the classic 24 bit RGB (which assigns 8 bits to each of the RGB components), RGB332 is very "KISS/suckless" and often good enough (especially with dithering) as it saves memory, avoids headaches with endianness and represents each color with just a single number (as opposed to 3), so it is ideal for simple and limited computers such as embedded. It is also in the public domain, unlike some other palettes, so it's additionally a legally safe choice. RGB332 also has a "sister palette" called RGB565 which uses two bytes instead of one and thus offers many more colors. And similarly it's also possible to go higher with the color depth into HDR realm with formats like R11G11B10 etcetera.
One disadvantage of plain 332 palette lies in the linearity of each component, i.e. lack of gamma correction, resulting in too many almost indistinguishable bright colors and too few darker ones { TODO: does a gamma corrected 332 exist? make it? ~drummyfish }. Another disadvantage is non-alignment of the blue component with red and green ones, i.e. while R/G components have 8 levels of intensity and hence step from 0 to 255 by 36.4, the B component only has 4 levels and steps by exactly 85, making it impossible to create exact shades of grey (which of course have to have all R, G and B components equal).
Actually here could arise the question of mapping the numeric values to real life colors, which means mapping a color model to a color space, and this can be done in several ways. In this article we conveniently define RGB332 in reference to the standard 24bit RGB and thus avoid dealing with any "real life colors" -- we assume that each RGB component in RGB332 maps linearly to the corresponding 24bit RGB component from 0 to 255. Whilst this is natural, it can also be inconvenient, for instance due to the fact that the R and G components step by an awkward non integer value of 36.4 which can hurt performance during conversions. For this reason the mapping can be done differently, e.g. using an approximate step of just 36 which will however get us only to the maximum value of 252 instead of 255. Or we can simply map the RGB332 components to the highest bits of each 24bit RGB component so that converting to a 332 value becomes only a matter of cutting off the bottom bits (doing a bit shift) and converting from 332 we insert a few lower bits -- but here we must decide if we insert 0 or 1 bits (or some combination thereof) and either way we'll end up with either imperfect minimum or imperfect maximum value (unless we do something "smarter", like repeating the lowest bits, but again that'll be more costly).
It's also possible to swap the order of component to get palettes such as BGR223, GBR323 etc.
Another variant of this format could be an 8bit color value under a different color model than RGB, for example HSV or HSL, which could eliminate some of the shortcomings in color distribution (described above), and would add the advantage of easy manipulation of brightness etc., but it would also somehow have to address the issue of multiple representations of colors such as black.
The RGB values of the 332 palette are following:
#000000 #000055 #0000aa #0000ff #002400 #002455 #0024aa #0024ff #004800 #004855 #0048aa #0048ff #006d00 #006d55 #006daa #006dff #009100 #009155 #0091aa #0091ff #00b600 #00b655 #00b6aa #00b6ff #00da00 #00da55 #00daaa #00daff #00ff00 #00ff55 #00ffaa #00ffff #240000 #240055 #2400aa #2400ff #242400 #242455 #2424aa #2424ff #244800 #244855 #2448aa #2448ff #246d00 #246d55 #246daa #246dff #249100 #249155 #2491aa #2491ff #24b600 #24b655 #24b6aa #24b6ff #24da00 #24da55 #24daaa #24daff #24ff00 #24ff55 #24ffaa #24ffff #480000 #480055 #4800aa #4800ff #482400 #482455 #4824aa #4824ff #484800 #484855 #4848aa #4848ff #486d00 #486d55 #486daa #486dff #489100 #489155 #4891aa #4891ff #48b600 #48b655 #48b6aa #48b6ff #48da00 #48da55 #48daaa #48daff #48ff00 #48ff55 #48ffaa #48ffff #6d0000 #6d0055 #6d00aa #6d00ff #6d2400 #6d2455 #6d24aa #6d24ff #6d4800 #6d4855 #6d48aa #6d48ff #6d6d00 #6d6d55 #6d6daa #6d6dff #6d9100 #6d9155 #6d91aa #6d91ff #6db600 #6db655 #6db6aa #6db6ff #6dda00 #6dda55 #6ddaaa #6ddaff #6dff00 #6dff55 #6dffaa #6dffff #910000 #910055 #9100aa #9100ff #912400 #912455 #9124aa #9124ff #914800 #914855 #9148aa #9148ff #916d00 #916d55 #916daa #916dff #919100 #919155 #9191aa #9191ff #91b600 #91b655 #91b6aa #91b6ff #91da00 #91da55 #91daaa #91daff #91ff00 #91ff55 #91ffaa #91ffff #b60000 #b60055 #b600aa #b600ff #b62400 #b62455 #b624aa #b624ff #b64800 #b64855 #b648aa #b648ff #b66d00 #b66d55 #b66daa #b66dff #b69100 #b69155 #b691aa #b691ff #b6b600 #b6b655 #b6b6aa #b6b6ff #b6da00 #b6da55 #b6daaa #b6daff #b6ff00 #b6ff55 #b6ffaa #b6ffff #da0000 #da0055 #da00aa #da00ff #da2400 #da2455 #da24aa #da24ff #da4800 #da4855 #da48aa #da48ff #da6d00 #da6d55 #da6daa #da6dff #da9100 #da9155 #da91aa #da91ff #dab600 #dab655 #dab6aa #dab6ff #dada00 #dada55 #dadaaa #dadaff #daff00 #daff55 #daffaa #daffff #ff0000 #ff0055 #ff00aa #ff00ff #ff2400 #ff2455 #ff24aa #ff24ff #ff4800 #ff4855 #ff48aa #ff48ff #ff6d00 #ff6d55 #ff6daa #ff6dff #ff9100 #ff9155 #ff91aa #ff91ff #ffb600 #ffb655 #ffb6aa #ffb6ff #ffda00 #ffda55 #ffdaaa #ffdaff #ffff00 #ffff55 #ffffaa #ffffff
And here's something that may come in very handy e.g. in pixel art: the APPARENT brightness values of all 332 colors by index (from black to white, 0 being minimum and 1023 maximum): { Don't dare to ask me how I made this. Yes I manually ordered all the colors comparing them one by one. ~drummyfish }
0, 118, 170, 233, 130, 140, 186, 251, 245, 253, 271, 324, 366, 364, 381, 432, 464, 467, 492, 508, 602, 604, 611, 636, 756, 767, 771, 782, 786, 788, 793, 799, 111, 131, 184, 248, 144, 159, 193, 267, 254, 258, 276, 330, 369, 377, 385, 435, 468, 488, 494, 519, 605, 606, 612, 637, 755, 768, 774, 781, 787, 789, 794, 800, 185, 201, 231, 306, 203, 210, 238, 310, 285, 292, 314, 368, 389, 393, 405, 448, 495, 501, 505, 552, 621, 626, 634, 645, 770, 773, 775, 785, 795, 790, 797, 804, 250, 269, 289, 336, 266, 275, 300, 344, 333, 341, 362, 409, 428, 433, 446, 487, 531, 535, 542, 577, 643, 646, 660, 693, 779, 780, 784, 798, 801, 802, 806, 811, 311, 317, 365, 404, 313, 347, 371, 413, 403, 407, 421, 463, 476, 485, 499, 523, 568, 575, 588, 613, 671, 676, 692, 712, 791, 792, 803, 812, 809, 810, 820, 844, 430, 437, 447, 466, 434, 440, 451, 475, 458, 461, 474, 514, 526, 538, 545, 571, 619, 622, 631, 661, 711, 727, 725, 750, 807, 819, 832, 845, 842, 850, 857, 867, 524, 532, 539, 556, 528, 536, 543, 557, 549, 553, 573, 592, 616, 623, 630, 663, 686, 687, 690, 710, 765, 769, 772, 783, 851, 858, 866, 888, 886, 890, 900, 923, 547, 550, 554, 581, 548, 551, 555, 582, 558, 576, 578, 625, 658, 655, 662, 678, 694, 696, 699, 744, 776, 777, 778, 805, 868, 870, 881, 896, 895, 901, 909, 1023
Here are C functions for converting RGB332 to RGB24 and back:
unsigned char rgbTo332(unsigned char red, unsigned char green, unsigned char blue)
{
return ((red / 32) << 5) | ((green / 32) << 2) | (blue / 64);
}
void rgbFrom332(unsigned char colorIndex, unsigned char *red, unsigned char *green, unsigned char *blue)
{
unsigned char value = (colorIndex >> 5) & 0x07;
*red = value != 7 ? value * 36 : 255;
value = (colorIndex >> 2) & 0x07;
*green = value != 7 ? value * 36 : 255;
value = colorIndex & 0x03;
*blue = (value != 3) ? value * 72 : 255;
}
In practice though it may be better to do something as follows, even if the conversions may be slightly inaccurate:
uint32_t rgbFrom332(uint8_t c332)
{
uint32_t c = ((c332 & 0x03) << 6);
c = ((c332 & 0xe0) << 16) | ((c332 & 0x1c) << 11) | c | (c >> 2);
return c | (c >> 3) | (c >> 5);
}
uint8_t rgbTo332(uint32_t c)
{
return ((c >> 16) & 0xe0) | ((c >> 11) & 0x1c) | ((c >> 6) & 0x03);
}
NOTE on rgbFrom332: a quick naive idea on getting the 8bit values for R, G and B components out of RGB332 color is to simply take the bits and pad them with zeros from bottom to the 8bit values -- though that will somewhat work, it won't be completely correct; consider e.g. an input value 11100000 where R is 111, i.e. at maximum -- by padding this to 11100000 we however don't get the desired maximum value 11111111 (if we pad with 1s we'll have the same problem for the zero value). This is why the code isn't as simple as the rgbTo332 function where we really do just chop off the unneeded bits.
Addition/subtraction of two RGB332 colors can be achieved simply by adding/subtracting the two color values as long as no over/underflow occurs in either component -- by adding the values we essentially perform a parallel addition/subtraction of all three components with only one operation. Over/underflow presents a problem because we want to clamp to maximum/minimum values so that, for example, brightening a white color doesn't result in black. Unfortunately safely ruling out over/underflow and then handling the clamp scenario can complicate things somewhat (one possible idea for overflow checking with addition may be this: addition of two values will not overflow if the total number of 1s in both values' highest two bits TOGETHER is at most 1). In any case, here is an attempt at a somewhat usable (branchless) functions for adding and subtracting two RGB332 colors with the desired clamping:
unsigned char add332(unsigned char c1, unsigned char c2)
{
unsigned int tmp = (c1 & 0xe3) + (c2 & 0xe3);
c1 = (c1 & 0x1c) + (c2 & 0x1c);
c2 = ((tmp & 0x104) | (c1 & 0x20)) >> 1;
return (c1 & 0x1c) | (tmp & 0xe3) | c2 | (c2 >> 1) | (c2 >> 2);
}
unsigned char sub332(unsigned char c1, unsigned char c2)
{
unsigned char a, b, c, r;
a = c1 & 0xe0;
b = c2 & 0xe0;
c = a >= b;
r = (a - b) & ((c << 5) | (c << 6) | (c << 7));
a = c1 & 0x1c;
b = c2 & 0x1c;
c = a >= b;
r |= (a - b) & ((c << 2) | (c << 3) | (c << 4));
a = c1 & 0x03;
b = c2 & 0x03;
c = a >= b;
return r | ((a - b) & (c | (c << 1)));
}
Addition/subtraction of colors can also be approximated in a very fast way using the OR/AND operation instead of arithmetic addition/subtraction -- however this only works sometimes (check visually). For example if you need to quickly brighten/darken all pixels in a 332 image, you can just OR/AND each pixel with these values:
brighten by more: doesn't really work anymore brighten by 3: | 0x6d (011 011 01) brighten by 2: | 0x49 (010 010 01) brighten by 1: | 0x24 (001 001 00) darken by 1: & 0xdb (110 110 11) darken by 2: & 0xb6 (101 101 10) darken by 3: & 0x92 (100 100 10) darken by more: doesn't really work anymore
Division by power of two is also fairly fast, you may simply shift the whole value right and zero appropriate bits, for example to darken a color twice you can just do (color >> 1) & 0x6d { Again code untested sorry. ~drummyfish }. Multiplying by power of two is not as simple though (consider e.g. a value 1011 shifted left once will result in a smaller value 0110; you may still try some tricks like a bitwise or with the previous value but that will already be an approximation);
{ TODO: Would it be possible to accurately add two 332 colors by adding all components in parallel using bitwise operators somehow? I briefly tried but the result seemed too complex to be worth it though. ~drummyfish }
Inverting a 332 color is done simply by inverting all bits in the color value.
TODO: blending?
RGB565 is color format, or a way of representing color with just 2 bytes (unlike traditional 24 bit RGB formats that use 3 bytes, one for each component), that is 16 bits (giving a total of 65536 distinct colors), by using 5 bits (highest) for red, 6 bits for green (to which human eye is most sensitive) and 5 bits for blue; it can also be seen as a color palette. It is similar to RGB332 -- it's basically a mid way between RGB332 and full 24bit RGB against which it saves one byte per pixel, but compared to RGB332 byte sex comes to play here. Practically speaking you will rarely need anything more than this, 65 thousand colors are absolutely sufficient for everything.
Yet another similar format to this one is RGB555 which sacrifices one useful bit for gaining the nice property of having the same size of each component. The one "wasted" bit may also be utilized, e.g. for marking transparency. Variants of RGB565 can also be obtained by swapping the order of components, e.g. BGR565 etc.
It would also be possible (but more complex) to use a different color model than RGB, for example HSV or HSL. In this case 6 bits should probably be allocated for the value (lightness) component, as human sight is more sensitive to this color component. However this would somehow have to address the issue of some colors (such as black) having multiple possible representations.
Here is a C code for the basic conversions to/from RGB565:
unsigned int rgbTo565(unsigned char red, unsigned char green,
unsigned char blue)
{
return (((unsigned int) (red / 8)) << 11) |
(((unsigned int) (green / 4)) << 5) | (blue / 8);
}
void rgbFrom565(unsigned int colorIndex, unsigned char *red,
unsigned char *green, unsigned char *blue)
{
unsigned char value = colorIndex >> 11;
*red = value != 31 ? value * 8 : 255;
value = (colorIndex >> 5) & 0x3f;
*green = value != 63 ? value * 4 : 255;
value = colorIndex & 0x1f;
*blue = value != 31 ? value * 8 : 255;
}
And also maybe a more practical variant:
uint16_t rgbTo565(uint32_t c)
{
return ((c >> 8) & 0xf800) | ((c >> 5) & 0x07e0) | ((c >> 3) & 0x001f);
}
uint32_t rgbFrom565(uint16_t c565)
{
uint32_t c =
((c565 & 0xf800) << 8) | ((c565 & 0x7e0) << 5) | ((c565 & 0x001f) << 3);
return c | ((c >> 5) & 0x070307);
}
Here are functions for adding and subtracting two RGB565 values with clamping:
unsigned int add565(unsigned int c1, unsigned int c2)
{
unsigned long tmp = (c1 & 0xf81f) + (c2 & 0xf81f);
c1 = (c1 & 0x07e0) + (c2 & 0x07e0);
c2 = (c1 & 0x0800) >> 1;
c2 |= c2 | (((tmp & 0x10020) | c2) >> 1);
c2 |= (c2 >> 1);
c2 |= (c2 >> 1);
c2 |= (c2 >> 2);
return (c1 & 0x07e0) | (tmp & 0xf81f) | c2;
}
unsigned int sub565(unsigned int c1, unsigned int c2)
{
unsigned int a, b, c, r;
a = c1 & 0xf800;
b = c2 & 0xf800;
c = (a >= b) << 11;
c |= (c << 1);
c |= (c << 1);
c |= (c << 2);
r = (a - b) & c;
a = c1 & 0x07e0;
b = c2 & 0x07e0;
c = (a >= b) << 5;
c |= (c << 1);
c |= (c << 1);
c |= (c << 3);
r |= (a - b) & c;
a = c1 & 0x001f;
b = c2 & 0x001f;
c = a >= b;
c |= (c << 1);
c |= (c << 1);
c |= (c << 2);
return r | ((a - b) & c);
}
There exist nice tricks you can do with colors represented this way, like quickly divide all three R, G and B components by a power of two just by doing one bit shift and logical AND to zero the highest bits of the components, or approximating addition of colors with logical OR and so on -- for details see the article on RGB332.
SAF is a LRS C library for small, very portable games (and possibly other kinds pf programs); it can also be seen as a fantasy console. It was made by drummyfish. The repository is available e.g. at https://git.coom.tech/drummyfish/SAF. MicroTD is an example of a LRS game made with SAF. By now there's a number of many other games and toys such as a procedural football simulator, chess, various minigames and even more complex games such as Anarch have been ported to it.
The whole SAF library is implemented in a single header file (currently a bit under 5000 lines of code, which is mostly due to including all the boilerplate for all possible platforms it supports, the actual SAF logic is pretty small) and offers a simple API for programming games, i.e. functions for drawing pixels to the screen, playing sounds, reading buttons, computing the sine function etc., and it handles boring/annoying issues such as the game main loop. It also has built-in a number of frontends that allow compiling a correctly made SAF games to any supported platform among which are SDL, SFML, X11, ncurses (terminal), even open consoles such as Pokitto, Arduboy or Gamebuino META. There is an option to auto-convert a color game to black-and-white only displays. Some PC frontends add emulator-like features such as time manipulation, pixelart upscaling, TAS support and so on.
Games made with SAF run in 64x64 resolution, with 256 colors (332 palette) and 25 FPS. They can use 7 input buttons (arrows, A, B and C), play 4 different sound effects and use 32 bytes of persistent memory, e.g. for savegames or highscores. These relatively low specifications are set on purpose so as to help portability, reduce bloat, frustration and friction. Many times good, entertaining games can be very simple, as is the case e.g. with Tetris, chess, various shmups, roguelikes and so on -- these are the kinds of games SAF is ideal for.
[] [][][][][]
[][][] [][]
[][] []
[] XX XX[]
[] XXXX []
[][] []
[][][] [][]
[] [][][][][]
SAF logo
microTD ________________________________________________________________ |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;' ';; ' ' ;;' ';;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;' ';, ,;, ,;, ,;;';;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;,;'' ''' ''' '', ,;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;',''''''''''''''''''',';;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;; ' ,;';;';, ;';'; ;';, ; ;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;; ' ;; ;; ;; ; ; ; ; ;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;; ' ;; ,,;;; ; ; ,; ; ;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;,', '''''' ' ''' ,',;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;,' ' ' ' ' ' ' ' ' ',;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| | ';;;' , ';;;' , ';;;' , ';;;' , ';;;' , ';;;' , ';;;' , ';;;' ,| |;, ' ,;;;, ' ,;;;, ' ,;;;, ' ,;;;, ' ,;;;, ' ,;;;, ' ,;;;, ' ,;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| | ,, , ,,, ,,, ,, | | ;''; ;,; ;,; ; | | ' ' ' ' ' ''' | |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;| |;';;;;;;'';;;;;;;;;;';;;;;;;;;;;;;;;;''';;;;;;;;;;;;;;;;;;;;;;;;| |; ,';;; ',,;;; ,;;;, ,;;;;,;;;;;;;;;;,, ;;;;;;;;;;;;;;;;;;;;;;;;| |;,,;;;;;,,;;;,,;;;;;,,;;;;,;;;;;;;;;;,,,;;;;;;;;;;;;;;;;;;;;;;;;| ----------------------------------------------------------------
screenshot of a SAF game (uTD) running in terminal with ncurses
Small3dlib (S3L) is a very portable LRS/suckless single header 3D software renderer library written by drummyfish in the C programming language. It is very efficient and runs on many resource-limited computers such as embedded open consoles. It is similar to TinyGL, but yet more simple. Small3dlib is public domain free software under CC0, written in under 3000 lines of code. The library is used in Licar.
The repository is available for example at https://git.coom.tech/drummyfish/small3dlib. The project got 34 stars on gitlab and 26 stars on codeberg before being banned for author's political opinions.
Small3dlib can be used for rendering 3D graphics on almost any device as it is written in pure C99 without any software and hardware dependencies; it doesn't use the standard library, floating point or GPU. It is also very flexible, not forcing any preprogrammed shaders -- instead it only computes which pixels should be rasterized and lets the programmer of the main application decide himself what should be done with these pixels (this is typically applying some shading and writing them to screen).
Some of the rendering features include:
##x
####xx
######xxxx
..xx ########xxxxx
.....xxx ##########xxxxxx
.......xxxxx #############xxxxxxx
.......xxxxxxx #############xxxxxxxx
.......xxxxxxxx #############xxxxxxxxxx
.......xxxxxxxxxx #############xxxxxxxxxxx
.......xxxxxxxxxxx #############xxxxxxxxxxxx
........xxxxxxxxxxxxx ##############xxxxxxxxxxxxx
.......xxxxxxxxxxxxxxx ##############xxxxxxxxxxxxxx
.......xxxxxxxxxxxxxxxx ##############xxxxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxx ##############xxxxxxxxxxxxxxxxx
.......xxxxxxxxxxxxxxxxxx ##############xxxxxxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxx ................xxxxxxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxx ................xxxxxxxxxxxxxxxxx
.......xxxxxxxxxxxxxxxxxx ...............xxxxxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxx ................xxxxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxx ...............xxxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxxx ...............xxxxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxx ................xxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxx ...............xxxxxxxxxxxx
........xxxxxxxxxxxxxxxxxxx ...............xxxxxxxxxx
........xxxxxxxxxxxxxxxxxxx ...............xxxxxxxxxx
.........xxxxxxxxxxxxxxxxxx ...............xxxxxxxx
#xxxxxxxxxxxxxxxxxxx ..............xxxxxxxx
#xxxxxxxxxxxxx ...............xxxxxx
xxxxxxx .............xxxxx
..........xxxx
........xxx
.....xx
...x
Simple ASCII rendering made with small3dlib.
Smallchesslib (SCL) is a small CC0 LRS/suckless chess library written in C by drummyfish. It is a single header library written in fewer than 4000 lines of code, with no dependencies and comes with a tiny engine called smolchess. It implements the basic chess rules as well as those of chess960, convenience functions (even primitive board picture export), handling of basic formats such as FEN and PGN, and a simple alpha-beta minimax AI -- smolchess played on lichess where it got a rating of about 1500 (https://lichess.org/@/smolchessbot); trying some test games against engines from CCRL, where the strongest stockfish 17 is currently rated 3642 Elo, revealed an Elo roughly around 600 (on occasion beat a 700 rated engine, consistently beat a 550 Elo one). The repository is available at https://git.coom.tech/drummyfish/smallchesslib. Smallchesslib/smolchess is extremely simple and has been tested to run even on super weak platform such as Arduboy which only has some 2 KB of RAM! That's pretty incredible, no?
A B C D E F G H
8 r:: b:: k:: n:r
7 :: p:p :: p::
6 p:b n:: :: :p
5 ::# :: :P :p
4 ::#B:: N:: ::
3 :P :: :: N::
2 :P P:B :: P:P
1 :R :: :K :: R
white played b5c4
black to move
ply number: 27
FEN: r1b1k1nr/1pp2p2/pbn4p/4P1p1/2B1N3/P4N2/1PPB2PP/R3K2R b KQ - 1 14
board static evaluation: 0.167969 (43)
board hash: 3262264934
phase: midgame
en passant: 0
50 move rule count: 1
PGN: 1. e4 e5 2. d4 d5 3. dxe5 dxe4 4. Qxd8+ Kxd8 5. f3 exf3 6. Nxf3 Ke8 7. Nc3 Bb4 8. a3 Bc5 9. Ne4 Bb6 10. Bg5 h6 11. Bf4 g5
12. Bb5+ Nc6 13. Bd2 a6 14. Bc4*
"Screenshot" of smolchess in action, playing against itself.
Technical details: it's no stockfish, simplicity is favored over strength. Evaluation function is hand-made with 16 bit integer score (no float!)). Board is represented as an array of bytes (in fact it's an array of ASCII characters that can conveniently be printed right out). AI uses basic recursive minimax and alpha-beta pruning, with quiescence handled by extending search for exchanges and checks. For simplicity there is no transposition table, opening book or similar fanciness, so the performance isn't great, but it manages to play some intermediate moves. Xboard is supported.
While there are many high level engines focusing on maximizing playing strength, there are almost no seriously simple ones focusing on other points -- smallchesslib/smolchess tries to change this. It can be used as an educational tool, a basis for other engines, a simple engine runnable on weak devices, a helper for processing standard chess formats etc.
{ Although I think it would be possible to increase the playing strength a lot considering there are extremely simple engines that reach much higher Elo, TBH I am still a noob at chess programming and I suspect I have some kind of oversight in the algorithm, perhaps something related to the horizon effect. The AI doesn't make obvious blunders like hanging pieces so it's not easy to pinpoint what exactly should be improved, perhaps it's just tuning of the evaluation function or low number of searched nodes -- I have quickly tried to do things such as tuning of the parameters, adding opening book or transposition table, but it never seemed to detectably increase playing strength, and I also don't have a modern computer that would allow me to do hardcore bruteforce tuning, my computational resources are limit. If someone experienced discovers what's the thing to improve, I'd be very glad, thank you. ~drummyfish }
WIP
Sphere is one of the most elemental 3D geometrical shapes that's defined as a set of all points that share the same distance r from given center point c. Every sphere is therefore uniquely defined by the point c and the distance r, which we call radius (that's half of diameter). Sphere is the equivalent of a circle, just in three dimensions, and the concept can be further generalized to higher dimensions (with the definition remaining the same) -- these "higher dimensional spheres" are named hyperspheres. Cutting a sphere with a plane going through the sphere's center point creates two equally sized hemispheres. It goes without saying that sphere is an object of immense importance: it's simple but hides profound concepts. In mathematics, physics and programming we know spheres for their special, many times optimal and/or very convenient properties such as having minimal surface to volume ratio, which then manifests in nature for example by animals curling to approximately spherical shapes when they want to stay warm. Spheres are beautiful and culturally they're a symbol of perfection; stars, planets, water droplets and bubbles take on the shape of a sphere, bounding spheres are used to accelerate computer programs such as physics engines, signals broadcast in empty space travel as an expanding sphere, sports make use of sphere-shaped balls, and we could probably spend the rest of eternity recounting more and more examples demonstrating this shape's significance.
Some data/facts/formulas/etc. related to spheres are the following:
A = 4 * pi * r^2.
V = 4/3 * pi * r^3.
sqrt(2 * h * r + h^2) and (using the formula for small circle area below we can compute that) he sees total area of (2 * pi * h) / (h + r). If we take the height above surface to be expressed as a fraction x of the sphere's radius, then the portion of total visible surface is (1 - 1 / (1 + x)) / 2. Plotting this we see this converges to 1/2, meaning you can only ever see less than half of any sphere's surface at once (not counting tricks with mirrors and cameras of course).
l = 2 * pi * r.
A2 = pi * (r2)^2. Now if r3 is the distance measured ON the big sphere's surface (i.e. going to be a little longer than r2), then it's: A2 = 2 * pi * r^2 * (1 - cos(r3/r)). { Thanks math exchange :D ~drummyfish } If we known height h of the spherical cap, then the area is A2 = 2 * pi * r * h and the volume inside the cap is V2 = pi * h^2 / 3 * (3 * r - h). From this it also follows that equally spaced parallel slices of a sphere create "spherical bands" of the same area (because (2 * pi * r * 2 * h) - (2 * pi * r * h) = (2 * pi * r * h)).
cos(c/r) = cos(a/r) * cos(b/r).
1/r^2.
p - c, normalize it and flip it. Any two spheres that touch by one point ALWAYS have their normals at the point of contact exactly aligned, just with opposite direction -- this is also very convenient e.g. in physics engines.
Locating individual points on a sphere's surface is complicated by the fact that the surface is curved (duh). Smaller parts of the surface are locally pretty close to a flat plain (see also Flat Earth), so in some cases the curvature can be safely neglected and we may happily continue using normal Cartesian coordinates. Nonetheless in many other situations we can't afford such luxury and will have to resort to something more complex and precise. Global navigation probably comes to mind as the first real world example but as programmers we may also imagine things like texturing or cellular automata. The question of choosing appropriate coordinates for a spherical surface is also related to map projections and tesselation.
The natural and likely most frequent choice is the latitude/longitude approach used for navigation on Earth (see also Euler angles, this is the same but without roll). Here we use two coordinates: latitude to say the "vertical" position between north and south pole and longitude for "horizontal" distance from some conventionally chosen meridian. The principle is pretty straightforward, simple and on small scales approximates the Cartesian coordinates, which is awesome. But the system isn't without shortcomings, namely for example that longitude is meaningless on the poles (the problem known as Gimbal lock in Euler angles), i.e. it's redundant, the poles have infinitely many representations etcetc. In programming a disadvantage is non-uniform sampling -- that is if the coordinates are limited to finitely many values (integers, fixed point, floating point, ...), loads of points will be densely concentrated around the poles while the resolution around the equator will be sparser. Imagine you'd want to divide land on Earth with let's say a 256x256 grid mapped onto it by this scheme (y is latitude, x is longitude) -- it's going to be quite ugly, some cells will be small, others big and many will have awkward "tall but narrow" spaghetti shapes, PLUS dealing with the poles will be a pain. The system is also topologically non-spherical (well, prolly depends on how we treat the poles or something I dunno), we just forcefully project and display something non-spherical on a sphere, so this has no value for cellular automata experiments for example.
Hence the desire for better alternatives. Apparently there exist some already, based on space filling curves and similar stuff. But let's try to come up with something on our own.
A relatively cool idea is projecting cube onto a sphere, something used for instance with cubemaps in computer graphics. Coordinates on the surface of a cube are easy: you say which side the point is at (number 0 to 5) and then you give the point's position within that side with normal Cartesian coordinates. Now you can 1 to 1 pair every point of a spherical surface with every point of a cube's surface: simply put a small cube inside a sphere, align their centers, and then for any point p_c on the cube you get a unique point on the sphere p_s by casting a straight ray from the sphere's center through p_c, hitting a point on the sphere, which is p_s. Vice versa works the same. So you essentially divide the sphere's surface to 6 "squares" and continue with Cartesian coordinates in each. Sampling density (and thus also shapes of mapped grid cells) is good, although not perfect. A slight disadvantage may be a little more difficult (slow) math and potential branches in code (due to 6 individual sides). This approach is well usable for cellular automata already, however with one caveat: pinch points. Pinch points correspond to the vertices of the cube, i.e. there are 8 of them, and their problem is that there will be only 3 cells around every pinch point while every other point will have 4 points around (as is the case with planar cellular automata as well). This is troublesome because it messes with rules of cellular automata but not just that, it also fucks up some assumption such as that going "up, left, down and right" gets you to the where you started. Maybe it doesn't seems too bad but the problem's a real bitch.
Now let's keep following the same line of thought with projecting regular tetrahedron (3-simplex) onto a sphere. We lose the convenient Cartesian grid but obtain something nice in return. Say we want to locate point p on the sphere with certain accuracy. Initially we start with the sphere split in 4 "triangular" parts (the projected tetrahedron faces), so we can start by saying which of these 4 regions p lies in -- this requires 2 bits (able to express 4 value). To give the position more precisely, we can now subdivide our triangular region into 4 new triangles by splitting each side in two and connecting them. Again we require 2 bits to reveal which of the new triangles p occupies. And we can repeat this process as many times we like to get arbitrarily close to p. The cool thing is that our coordinates are now elegantly a single string of (pairs of) bits and they get more precise the longer the string is -- we can even cut off some bits from the end to get shorter coordinates for the price of lowering our resolution. Note however that the triangles won't generally be of the same size and area (consider for example that on a spherical surface it no longer holds that subdividing an equilateral triangle by splitting its sides in halves gives us 4 new equilateral triangles of same area). Octahedron can alternatively be considered as the starting shape: it's less elegant (the first choice requires 3 bits, not 2, since there are 8 faces) but possibly aligns better with other coordinate systems, for example there is exact north and south pole, equator and 4 equally spaced meridians. However should you decide for this you might as well go with the "cubemap" approach and treat each of its sides with subdivisions too (you can split a square face into four new squares, that's 2 bits again), then you'll get back the nice square grid. In 3D computer graphics we often use icospheres which start with icosahedron (20 triangular faces) and then keep subdividing the triangles as per above with the reason being that this results in very nice triangles that are "almost" equilateral and have similar areas. Bad news is that any of these systems still retains pinch points (although tetrahedron will only have 4) -- only Platonic solids have no pinch points.
This projection of shapes still leaves many ideas to be explored, for example: take a square grid, then kinda "reshape" it to a circular shape and project it top-down onto the sphere, which will cover the upper hemisphere, and do the same with another grid for the lower hemisphere (and connect the grids together by their touching sides). This will have some badly shaped cells and 4 pinch points, but can be usable and will be simple (it's basically the normal torus "wrap-around" grid). And so forth, feel free to think up more stuff like this. See also Platonic solids.
Now here is a sketch of the space filling curve idea. Quick recap/definition of a space filling curve for our purposes: it's an infinitely long fractal path in flat 2D plane that starts at origin (point [0,0]) and visits EVERY point in the unit square (from [0,0] to [1,1]) EXACTLY ONCE without ever stepping outside the square. Position on the curve is given by parameter t which is a single real number from 0 to 1. There exist various such curves, e.g. Hilbert curve and Peano curve -- let's go with Hilbert whose end lies in point [1,0] (or [0,1] if we transpose it). Now we can start with the "cubemap" trick: we project a cube onto our sphere and then simply fill each of the cube's sides (a unit square) with Hilbert curve so that each side's curve end connects to the next side curve's beginning. Remember that each cube's surface point corresponds 1:1 to the all of the sphere's surface points, we just have to do some projections. So now we can identify any surface point with a SINGLE real parameter that goes from 0 to 6 (there are 6 cube sides, each with a parameter going from 0 to 1). This may need some refinement due to edges for example (edge points may be touched by two side's curves), but it's a start. In fact it appears to be best to think in terms of subdivisions again: level 0 says the specific cube side (0 to 5), level 1 says the subsquare of the side, level 2 says the subsquare of the level 1 subsquare etc. -- this way we can treat the coordinates as a string of digits whose resolution increases with the string length. { I think this is actually one of the existing coordinate systems, think I saw it on Wikipedia. Hope it's not patented or something. ~drummyfish } Perhaps it could also be considered to start with just planes instead of a cube or with tetrahedron (see above) and then use a triangle filling curve.
.-------top------.
; 11==12 21==22 ;
; || || || || ;
; 10 13==20 23 ;
; || || ;
; 03==02 31==30 ;
; || || ;
; 00==01 32==33 ;
'-------------||-'
||
.------front--||-. .------right-----.
: 51==50==43 40 : : 91==92 A1==A2 :
: || || || : : || || || || :
: 52==53 42==41 : : 90 93==A0 A3 :
: || : : || || :
: 61==60 71==72 : : 83==82 B1==B0 :
: || || || : : || || :
: 62==63==70 73======80==81 B2==B3 :
'----------------' '-------------||-'
||
.-----bottom--||-. .------back------.
: D1==D0==C3 C0 : : H1==H2 I1==I2 :
: || || || : : || || || || :
: D2==D3 C2==C1 : : H0 H3==I0 I3 :
: || : : || || :
: E1==E0 F1==F2 : : G3==G2 J1==J0 :
: || || || : : || || :
: E2==E3==F0 F3======G0==G1 J2==J3 :
'----------------' '-------------||-'
||
.------left---||-.
: L1==L0==K3 K0 :
: || || || :
: L2==L3 K2==K1 :
: || :
: M1==M0 N1==N2 :
: || || || :
: M2==M3==N0 N3 :
'----------------'
Continuous path over cube's surface (that can be projected onto a sphere) with Hilbert's space filling curve. It's even a closed loop.
Yet a different approach could be to start with a single cell on the north pole and then adding rows to the south while always subdividing each cell in two, i.e. doubling the number of cells in each subsequent row up to the equator, then reversing the process and ending up with a single cell on the south pole again. The following picture illustrates the start of this process:
__________
_.-''' 7 '''-._
_/ ________ \_
_/\_ _-''' | '''-_ _/\_
/ \' 3 ____|____ 6 '/ \
/ 13 / .' | '. \ 8 \
| | | __|__ | | |
|----|----| 2 | 0 | 1 |----|----|
| | | |_____| | | |
| 12 | '. | .' | 9 |
\ \_ 4 '.___|___.' 5 _/ /
| _/\_ | _/\_ |
\_/ '-.____|____.-' \_/
'-_ 11 | 10 _-'
'--..____|____..--'
Each row will therefore have a cell count that's power of two, which can be an advantage for performance, but the number will also grow quickly, so with a lot of rows we could perhaps duplicate some rows without subdividing them, but this will further complicate the layout etc., so instead of subdividing cells for each row (multiplying the cell number by a constant) we may consider just ADDING some constant number of cells (but then there is the question of how they're going to align etc.). A disadvantage is a little awkward topology in that for example it's not clear whether going down (south) from cell 4 gets us to cell 11 or 12.
Another idea is to consider a spiral starting at the north pole, then going down and around until it hits the south pole. This in itself isn't a space filling curve, so we can't increase accuracy, but if we know desired accuracy beforehand, we can accordingly choose the system's parameters (probably two: the total number of points along the spiral and the number of turns the spiral makes around the globe). With this we'll be able to specify position with one parameter like with space filling curves and won't be dealing with the "Gimbal lock" headaches.
Deserving a few words is also the following imperfect but interesting idea. Imagine we cut off the north and south pole caps of the sphere and thereby limit ourselves to only "non-polar" regions of the sphere (with Earth we oftentimes ignore polar regions too). We are now left with something like a "fat cylinder" or a tyre. We can project a cylinder onto this, and cylinder's surface can nicely be covered with a Cartesian grid whose left side is connected to its right side so that one can keep going around indefinitely. However we can also allow going "over the border" up and down. If we connected top to bottom the same way to the left/right sides, we'd get a torus (doughnut) topology, and that's not quite a sphere (going over north pole you'd suddenly appear at the south pole). What we can do is connect both top and bottom side of the grid EACH TO ITSELF, in a "special way". Imagine you cross the northern border -- then you'll appear on the cell that's half the grid width to the right (or left, it doesn't matter) and turned upside down. The same would happen on the southern border. Visually you can imagine it simply as "skipping" the polar cap to the cell that's straight forward in front of you. Sure, this still sucks in many ways (no poles, sampling density still bad, ...) but it's a relatively simple way to get "something like a sphere".
TODO: moar, maybe "quaternions without roll"?
Square root (sometimes shortened to sqrt) of number a is such a number b that b^2 = a, for example 3 is a square root of 9 because 3^2 = 9. Finding square root is one of the most basic and important operations in math and programming, e.g. for computing distances, solving quadratic equations etc. Square root is a special case of finding Nth root of a number for N = 2. Square root of a number doesn't have to be a whole number; in fact if the square isn't a whole number, it is always an irrational number (i.e. it can't be expressed as a fraction of two integers, for example square root of two is approximately 1.414...); and it doesn't even have to be a real number (e.g. square root of -1 is i). Strictly speaking there may exist multiple square roots of a number, for example both 5 and -5 are square roots of 25 -- the positive square root is called principal square root; principal square root of x is the same number we get when we raise x to 1/2, and this is what we are usually interested in -- from now on by square root we will implicitly mean principal square root. Programmers write square root of x as sqrt(x) (which should give the same result as raising to 1/2, i.e. pow(x,0.5)), mathematicians write it as:
_ 1/2 \/x = x
Here is the graph of square root function (notice it's a parabola flipped by the diagonal axis, for square root is an inverse function to the function x^2):
^ sqrt(x)
| : : : : :
3 + ~ ~ ~ + ~ ~ ~ + ~ ~ ~ + ~ ~ ~ + ~ ~ ~ + ~
| : : : : :
| : : : : ___....--
2 + ~ ~ ~ + ~ ~ ~ + ~ ~ ~ + ~ __..---'"""": ~
| : : __..--"""" : :
| : __.--'" : : :
1 + ~ ~ _--'" ~ ~ + ~ ~ ~ + ~ ~ ~ + ~ ~ ~ + ~
| _-" : : : : :
| / : : : : :
----+"------|-------|-------|-------|-------|----> x
|0 1 2 3 4 5
|
A table of a few values may come handy as well:
| x | ~sqrt(x) |
|---|---|
| 0 | 0 |
| 0.5 | 0.70710... |
| 1 | 1 |
| 1.5 | 1.22474... |
| 2 | 1.41421... |
| 2.5 | 1.58113... |
| 3 | 1.73205... |
| 3.5 | 1.87082... |
| 4 | 2 |
| 4.5 | 2.12132... |
| 5 | 2.23606... |
| 5.5 | 2.34520... |
| 6 | 2.44949... |
| 6.5 | 2.54951... |
| 7 | 2.64575... |
| 7.5 | 2.73861... |
| 8 | 2.82842... |
| 8.5 | 2.91547... |
| 9 | 3 |
| 9.5 | 3.08220... |
| 10 | 3.16227... |
TODO: more
Square root is a very common operation and oftentimes has to be VERY fast -- it's used a lot for example in computer graphics and so gets executed several million times per second. For this reason there oftentimes exist special instructions and otherwise hardware accelerated options, you will very likely have such function around on most computers -- in C math standard library there's the sqrt floating point function that will probably be very fast. But let's now consider you want to program your own square root, which may happen for example when dealing with embedded computers.
If we really need extreme speed, we may always use a look up table with precomputed values. Of course a table with ALL the values would be very big, but remember we can make a much smaller table (where each item spans a bigger range) that will provide just a quick estimate from which you'll make just a few extra iterations towards the correct answer.
Within desired precision square root can be relatively quickly computed iteratively by binary search. Here is a simple C function computing integer square root this way:
{ I checked the code works for all values with 32 bit integer (remember that C specification allows integers to be as small as 16 bit though, remember to adjust the constants if you suspect you might hit this, overflows may happen). On my computer I measured this to be about 2 (with compiler optimization) to 4 (without) times slower than using the hardware accelerated float point stdlib function. ~drummyfish }
unsigned int sqrtInt(unsigned int x)
{
unsigned int m, l = 0,
r = x < 8300000 ? x / 128 + 40 : 65535; // upper bound est. for 32 bit int
//r = x < 15000 ? x / 64 + 20 : 255; // <-- for 16 bit int use this
while (1)
{
if (l > r)
break;
m = (l + r) / 2;
if (m * m > x)
r = m - 1;
else
l = m + 1;
}
return r;
}
But now let's take a look at maybe even a better algorithm -- it only gives an approximation, however it's pretty accurate and we may modify it to give a precise value by simply adjusting the estimate at the end. The advantage is that the approximation only uses bit shifts, no multiplication! This can be crucial on some simple platforms where multiplication may be expensive. Furthermore the algorithm is pretty simple, it works like this: given input number x, we may imagine we have a rectangle of size 1 times x; now we can try to make it into square by doubling the first side and halving the other. If we get equal sides, the side length is the square root. Of course we don't always iterate to the same side sizes -- if the first side gets bigger than the other, we stop and simply average them -- and that's it! Here's the code:
{ I remember I came up with a simple form of this algorithm when I was still in elementary school, however it's pretty obvious so it probably already exists, I didn't bother checking. Measuring the speed of this the pure approximation is very fast, I measured it basically at the same speed as the stdlib float square root; the exact version is of course considerably slower -- anyway for lower input values I measured it even faster than the binary search, however for higher values not anymore. ~drummyfish }
unsigned int sqrtIntApprox(unsigned int x)
{
unsigned int a = 1;
while (x > a)
{
a <<= 1;
x >>= 1;
}
return (a + x) >> 1;
}
unsigned int sqrtIntExact(unsigned int x)
{
unsigned int a = 1, b = x;
while (b > a)
{
a <<= 1;
b >>= 1;
}
a = (a + b) >> 1;
while (a * a > x) // iterate to exact value
a--;
return a;
}
TODO: Heron's method?
The following is a non-iterative approximation of integer square root in C that has acceptable accuracy to about 1 million (maximum error from 1000 to 1000000 is about 7%): { Painstakingly made by me. This one was even faster than the stdlib function! ~drummyfish }
int32_t sqrtApprox(int32_t x)
{
return
(x < 1024) ?
(-2400 / (x + 120) + x / 64 + 20) :
((x < 93580) ?
(-1000000 / (x + 8000) + x / 512 + 142) :
(-75000000 / (x + 160000) + x / 2048 + 565));
}
If we need floating point square root, we can very well use numerical methods: for example wanting to find square root of a we may apply Newton's method to arrive at the formula:
`x[n + 1] = 1/2 * (x[n] + a / x[n])
into which we may substitute the initial estimate as x[0] and then just keep evaluating the series until the error becomes small enough. Here this is implemented in C (to keep it simple performing a fixed number of iterations that showed to give accurate results even for high values):
double sqrtF(double x)
{
double r = x / 2 + 1;
for (int i = 0; i < 20; ++i)
r = 0.5 * (r + x / r);
return r;
}
For the real curious it's possible to look further into how serious C libraries such as musl or glibc do it, but it's usually not a pleasant sight to behold.
Not to be confused with seppuku.
Sudoku is a puzzle that's based on filling a grid with numbers that is hugely popular even among normies such as grandmas and grandpas who find this stuff in magazines for elderly people. The goal is to fill in all squares of a 9x9 grid, prefilled with a few clue digits, with digits 1 to 9 so that no digit repeats in any column, row and 3x3 subgrid. It is like a crosswords puzzle for people who lack general knowledge, but it's also pretty suckless, pure logic-based puzzle whose generation and solving can be relatively easily automated (unlike generating crosswords which requires some big databases). The puzzle is a pretty fun singleplayer game, posing opportunities for nice mathematical research and analysis as well as a comfy programming exercise. Sudokus are a bit similar to magic squares. There also exist many similar kinds of puzzles that work on the principle of filling a grid so as to satisfy certain rules given initial clues, many of these are implemented e.g. in Simon Tatham's Portable Puzzle Collection.
Curiously sudoku has its origins in agricultural designs in which people wanted to lay out fields of different plants in more or less uniform distributions (or something like that, there are some papers about this from 1950s). The puzzle itself became popular in Japan in about 1980s and experienced a boom of popularity in the western world some time after 2000 (similar Asian puzzle boom was historically seen e.g. with tangram).
The following is an example of a sudoku puzzle with only the initial clues given:
_________________ | 3 1| 5 7| 6 | | |9 8| 4 | |4_7_8|6_ _2|1_ _5| |7 5| 6 |4 | | 6| 8 1|7 2 | | _ _ |7_ _3|6_5_ | |5 6 | 9 | 2| | |1 5|9 6| | _ _3|8_2_6| _ _4|
The solution to the above is:
_________________ |9 3 1|4 5 7|2 6 8| |6 5 2|9 1 8|3 4 7| |4_7_8|6_3_2|1_9_5| |7 1 5|2 6 9|4 8 3| |3 4 6|5 8 1|7 2 9| |2_8_9|7_4_3|6_5_1| |5 6 7|3 9 4|8 1 2| |8 2 4|1 7 5|9 3 6| |1_9_3|8_2_6|5_7_4|
We can see neither digit in the solution repeats in any column, row and any of the 9 marked 3x3 subgrids or, in other words, the digits 1 to 9 appear in each column, row and subgrid exactly once. These are basically the whole rules.
We generally want a sudoku puzzle to have initial clues such that there is exactly one possible (unique) solution. For this sudoku has to have at least 17 clues (this was proven by a computer). Why do we want this? Probably because in the puzzle world it is simply nice to have a unique solution so that human solvers can check whether they got it right at the back page of the magazine. This constraint is also mathematically more interesting.
How many possible sudokus are there? Well, this depends on how we view the problem: let's call one sudoku one grid completely filled according to the rules of sudoku. Now if we consider all possible such grids, there are 6670903752021072936960 of them. However some of these grids are "basically the same" because we can e.g. swap all 3s and 5s in any grid and we get basically the same thing as digits are nothing more than symbols here. We can also e.g. flip the grid horizontally and it's basically the same. If we take such things into account, there remain "only" 5472730538 essentially different sudokus.
Sudoku puzzles are sometimes assigned a difficulty rating that is based e.g. on the techniques required for its solving.
Of course there exist variants of sudoku, e.g. with different grid sizes, extended to 3D, different constraints on placing the numbers etc.
There are two topics to address: solving sudoku by people and solving sudoku by computers.
Humans use almost exclusively logical reasoning techniques to solve sudoku, which include:
Relatively recently (sometime in 2020s) there was a quite huge discovery/highlight of so called Phistomefel ring -- this is an area on the sudoku board that will always contain the same values as another area, which can greatly help in finding solutions (and also in generating sudokus). Consider the following patterns:
_________________ _________________ |B B .|. . .|. B B| |. . .|C C C|. . .| |B B .|. . .|. B B| |. . .|C C C|. . .| |._._A|A_A_A|A_._.| |D_D_D|._._.|D_D_D| |. . A|. . .|A . .| |D D D|. . .|D D D| |. . A|. . .|A . .| |. . .|C C C|. . .| ... |._._A|._._.|A_._.| |._._.|C_C_C|._._.| |. . A|A A A|A . .| |. . .|. . .|. . .| |B B .|. . .|. B B| |. . .|. . .|. . .| |B_B_.|._._.|._B_B| |._._.|._._.|._._.|
On the left we see the Phistomefel ring -- the set of A squares (the ring) will always contain the same values as the set of B squares! (Check it on our example sudoku above.) That's it, it's pretty simple, and it's simple to prove too (quickly: consider set S1 = row3 + row7 + 3x3square4 + 3x3square6, and S2 = column1 + column2 + column8 + column9; it can be seen that S1 and S2 contain the same values; now remove from both sets their intersection -- we have removed the same values from both sets so they still contain the same values, set S1 is now the Phistomefel ring, S2 are the corners). A nice thing is that you can find more such relationship just using the simple idea of manipulating sets (the other example, values in sets C and D also have to be the same etc.).
For computers the traditional 9x9 sudoku is nowadays pretty easy to solve, however solving an NxN sudoku is an NP complete problem, i.e. there most likely doesn't exist a "fast" algorithm for solving a generalized NxN sudoku, even though the common 9x9 variant can still be solved pretty quickly with today's computers by using some kind of "smart" brute force, for example backtracking (or another state tree search) which recursively tries all possibilities and at any violation of the rules gets one step back to change the previous number. Besides this a computer can of course use all the reasoning techniques that humans use such as creating sets of possible values for each square and reducing those sets until only one possibility stays. The approach of reasoning and brute forcing may also be combined: first apply the former and when stuck fall back to the latter.
{ I haven't personally tested these methods yet, I'm just writing what I've read on some web pages and ideas that come to my mind. ~drummyfish }
Generating sudoku puzzles is non-trivial. There are potentially many different algorithms to do it, here we just foreshadow some common simple approaches.
Note that during generation of the sudoku you may utilize the knowledge of some inherent relationship between squares, e.g. the above mentioned Phistomefel ring.
Firstly we need to have implemented basic code for checking the validity of a grid and also some automatic solver, e.g. based on backtracking.
For generating a sudoku we usually start with a completely filled grid and keep removing numbers to leave only a few ones that become the initial clues. For this we have to know how to generate the solved grids. Dumb brute force (i.e. generating completely random grids and testing their validity) won't work here as the probability of finding a valid grid this way is astronomically low (seems around 10^(-56)). What may work is to randomly fill a few squares so that they don't break the rules and then apply our solver to fill in the rest of the squares. Yet a simpler way may be to have a database of a few hand-made grids, then we pick on of them and apply some transformations that keep the validity of the grid which include swapping any two columns, swapping any two rows, tansposing, flipping the grid, rotating it 90 degrees or swapping any two digits (e.g. swap all 7s with all 9s).
With having a completely filled grid generating a non-unique (more than one solution) sudoku puzzle is trivial -- just take some completely filled grid and remove a few numbers. But as stated, we usually don't want non-unique sudokus.
For a unique solution sudoku we have to check there still exists exactly one solution after removing any numbers from the grid, for which we can again use our solver. Of course we should optimize this process by quitting the check after finding more than one solution, we don't need to know the exact count of the solutions, only whether it differs from one.
The matter of generating sudokus is further complicated by taking into account the difficulty rating of the puzzle.
Here is a C code that solves sudoku with brute force (note that for too many empty squares it won't be usable as it might run for years):
#include <stdio.h>
char sudoku[9 * 9] = // 0s for empty squares
{
9, 3, 1, 0, 5, 7, 2, 6, 0,
6, 5, 0, 9, 1, 8, 3, 4, 7,
4, 7, 8, 6, 3, 2, 1, 9, 5,
7, 1, 5, 2, 6, 0, 4, 8, 3,
3, 0, 6, 5, 8, 1, 7, 2, 9,
2, 8, 9, 7, 0, 3, 6, 5, 1,
5, 6, 7, 3, 9, 0, 8, 1, 2,
8, 2, 0, 1, 7, 5, 9, 3, 6,
1, 9, 3, 8, 2, 6, 5, 0, 4
};
void print(void)
{
puts("-----------------");
for (int i = 0; i < 9 * 9; ++i)
{
putchar('0' + sudoku[i]);
putchar(i % 9 != 8 ? ' ' : '\n');
}
}
int isValid(void) // checks if whole sudoku is valid
{
for (int i = 0; i < 9; ++i)
{
unsigned int m1 = 0, m2 = 0, m3 = 0; // bit masks of each group
char *s1 = sudoku + i, // column
*s2 = sudoku + i * 9, // row
*s3 = sudoku + (i / 3) * (3 * 3 * 3) + (i % 3) * 3; // square
for (int j = 0; j < 9; ++j)
{
m1 |= (1 << (*s1));
m2 |= (1 << (*s2));
m3 |= (1 << (*s3));
s1 += 9;
s2 += 1;
s3 += (j % 3 != 2) ? 1 : 7;
}
if ((m1 != m2) || (m1 != m3) || (m1 != 0x03fe)) // all must be 1111111110
return 0;
}
return 1;
}
int printCounter = 0;
int solve(void) // find first empty square and brute forces all values on it
{
char *square = sudoku;
printCounter++;
if (printCounter % 512 == 0) // just to limit printing speed
print();
for (int j = 0; j < 9 * 9; ++j, ++square) // find first empty square
if (!(*square)) // empty square?
{
while (1) // try all possible values in the square
{
*square = ((*square) + 1) % 10;
if (!(*square)) // overflow to 0 => we tried all values now
break;
if (solve()) // recursively solve the next empty square
return 1;
}
return 0; // no value led to solution => can't be solved
}
// no empty square found, the sudoku is filled
return isValid();
}
int main(void)
{
/* Here we could do some initial attempts at reasoning and filling in
digits by "logic" before getting to brute force -- with too many empty
squares brute force will take forever. However this is left as an
exercise :-) */
int success = solve();
print();
puts(success ? "solved" : "couldn't solve it");
return 0;
}
Software (SW) rendering refers to rendering computer graphics without the aid of graphics card (GPU), or in other words computing images only with the CPU. The opposite is called GPU accelerated or hardware accelerated rendering. Most commonly the term SW rendering means rendering 3D graphics but may as well refer to other types of graphics such as drawing fonts or video. Before the invention of GPU cards all rendering was done in software of course -- games such as Quake or Thief were designed with SW rendering and only added optional GPU acceleration later. SW rendering for traditional 3D graphics is also called software rasterization, for rasterization is the basis of current real-time 3D graphics.
It must be noted that SW rendering doesn't mean the program is never touching GPU at all, in fact most personal computers nowadays REQUIRE some kind of GPU to even display anything. Even if GPU is involved in presentation of the computed image, we still talk about SW rendering as long as the image was computed by the CPU. Of course there may exist a gray area where SW and hardware accelerated rendering are combined.
Insofar as advantages and disadvantages of SW rendering go, there are both of course, but from our point of view the advantages prevail (at least given only capitalist GPUs exist nowadays). First of all it must be said that it is much slower than GPU graphics -- GPUs are designed to perform graphics-specific operations very quickly and, more importantly, they can process many pixels (and other elements) in parallel, while a CPU has to compute pixels sequentially one by one and that in addition to all other computations it is otherwise performing. This causes a much lower FPS in SW rendering. For this reasons SW rendering is also normally of lower quality (lower resolution, no antialiasing, nearest neighbour texture filtering, no mipmaps, ...) to allow workable FPS. Nevertheless thanks to the ginormous speeds of today's CPUs simple fullscreen SW rendering can be pretty fast on PCs and achieve even above 60 FPS; on slower CPUs (typically embedded) SW rendering is usable normally at around 30 FPS if resolutions are kept small.
On the other hand SW rendering is more portable (as it can be written purely in a portable language such as C), less bloated and eliminates the dependency on GPU so it will be supported almost anywhere as every computer has a CPU, while not all computers (such as embedded devices) have a GPU (or, if they do, it may not be sufficient, supported or have a required driver). SW rendering may also be implemented in a simpler way and it may be easier to deal with as there is e.g. no need to write shaders in a special language, manage transfer of data between CPU and GPU or deal with parallel programming. SW rendering is the KISS approach, which also implies it's more future proof etc. Furthermore SW rendering is more predictable -- this is because GPUs are highly magical devices optimized to work well under certain assumptions (e.g. not drawing too many small triangles) and each GPU (or even the same GPU with different drivers) may react differently to what we're rendering, so even though GPU performance will be higher, it will be much more difficult to be kept stable and predictable over a wide range of different GPUs and drivers.
SW rendering may also utilize (at least more easily and without penalties) a much wider variety of rendering techniques than only 3D rasterization traditionally used with GPUs and their APIs, thanks to not being limited by hard-wired pipelines, i.e. it is more flexible. This may include splatting, raytracing or BSP rendering (and many other "pseudo 3D" techniques) and even completely different rendering paradigms such as frameless rendering.
Rendering frameworks and libraries commonly offer both options: accelerated rendering using GPU and SW rendering as a fallback (should the prior be unavailable for whatever reason). Sometimes there exists a rendering API that has both an accelerated and software implementation (e.g. TinyGL for OpenGL).
For simpler and even somewhat more complex graphics purely software rendering is mostly the best choice. LRS suggests you prefer this kind of rendering for its simplicity and portability, at least as one possible option. On devices with lower resolution not many pixels need to be computed so SW rendering can actually be pretty fast despite low specs, and on "big" computers there is nowadays usually an extremely fast CPU available that can handle comfortable FPS at higher resolutions. There is a LRS software renderer you can use: small3dlib.
SW renderers are also written for the purpose of verifying rendering hardware, i.e. as a reference implementation.
Some SW renderers make use of specialized CPU instructions such as MMX which can make SW rendering faster thanks to handling multiple data in a single step. This is kind of a mid way: it is not using a GPU per se but only a mild form of hardware acceleration. The speed won't reach that of a GPU but will outperform a "pure" SW renderer. However the disadvantage of a hardware dependency is still present: the CPU has to support the MMX instruction set. Good renderers only use these instructions optionally and fall back to general implementation in case MMX is not supported.
{ In case small3dlib is somehow not enough for you :) ~drummyfish }
Difficulty of this task depends on features you want -- a super simple flat shaded (no textures, no smooth shading) renderer is relatively easy to make, especially if you don't need movable camera, can afford to use floating point etc. See the details of 3D rendering, especially how the GPU pipelines work, and try to imitate them in software. The core of these renderers is the triangle rasterization algorithm which, if you want, can be very simple -- even a naive one will give workable results -- or pretty complex and advanced, using various optimizations and things such as the top-left rule to guarantee no holes and overlaps of triangles. Remember this function will likely be the performance bottleneck of your renderer so you want to put effort into optimizing it to achieve good FPS. Once you have triangle rasterization, you can draw 3D models which consist of vertices (points in 3D space) and triangles between these vertices (it's very simple to load simple 3D models e.g. from the obj format) -- you simply project (using perspective) 3D position of each vertex to screen coordinates and draw triangles between these pixels with the rasterization algorithm. Here you need to also solve visibility, i.e. possible overlap of triangles on the screen and correctly drawing those nearer the view in front of those that are further away -- a very simple solution is a z buffer, but to save memory you can also e.g. sort the triangles by distance and draw them back-to-front (painter's algorithm). You may add a scene data structure that can hold multiple models to be rendered. If you additionally want to have movable camera and models that can be transformed (moved, rotated, scaled, ...), you will additionally need to look into some linear algebra and transform matrices that allow to efficiently compute positions of vertices of a transformed model against a transformed camera -- you do this the same way as basically all other 3D engines (look up e.g. some OpenGL tutorials, see model/view/projection matrices etc.). If you also want texturing, the matters get again a bit more complicated, you need to compute barycentric coordinates (special coordinates within a triangle) as you're rasterizing the triangle, and possibly apply perspective correction (otherwise you'll be seeing distortions). You then map the barycentrics of each rasterized pixel to UV (texturing) coordinates which you use to retrieve specific pixels from a texture. On top of all this you may start adding all the advanced features of typical engines such as acceleration structures that for example discard models that are completely out of view, LOD, instancing, MIP maps and so on.
Possible tricks, cheats and optimizations you may utilize include:
These are some notable software renderers:
{ I made a simple tangram game in SAF, look it up if you want to play some tangram. ~drummyfish }
Tangram is an old, simple, yet highly amusing puzzle game wherein the player tries to compose a given shape (presented only by its silhouette) out of elementary geometric shapes such as triangles and squares. It is a rearrangement puzzle, a 2D game that's in principle similar e.g. to Soma cube, a game in which, similarly, one makes shapes out of basic parts that are however three dimensional. Tangram exploits the fact that from just a handful of building blocks it is possible to construct many thousands of shapes, some resembling animals, people and man made objects. This type of puzzle has been known for many centuries -- the oldest recorded tangram is Archimedes' box (square divided into 14 pieces), over 2000 years old. In general any such puzzle is called tangram, i.e. it is seen as a family of puzzle games, however tangram may also stand for modern tangram: one with 7 polygons, originating from 18th century China from where its popularity spread to the west and even briefly sparked a so called "tangram craze" around the year 1818. Unless mentioned otherwise, we'll be talking about this modern version from now on.
_________________ |\_ big _/| | \_ tri _/ | |tri_\_ _/ | | _/ \_ _/ big | |<_ sqr _X_ tri | | \_ _/tri\_ | |mid \_______\_ | | tri \_ para \_ | |________\_______\|
Divide square like this to get the 7 tangram pieces. Note that the parallelogram is allowed to be flipped when creating shapes as it has no mirror symmetry (while all other shapes do).
Tangram is a cute, appealing game and LRS considers it one of the best games as it is beautifully simple to make and learn, it has practically no dependencies (computers, electricity, ... not even the sense of sight is strictly required), yet it offers countless hours of fun and holds potential for gaining deep insight, there is art in shape composition, math in counting possibilities, good exercise for programmers and much more.
Tangram ordinarily comes as a box with 7 pieces and a number of cards depicting shapes for the player to solve. On its back side each card shows a solution. Some of the shapes are easy to solve and some are very difficult.
_/|
/ | _/|\_
|\_ | / | \_
| \| | | \_
| _/ _ | |______\
|/ \_ ________ _/ \_ | _/ \_
/ \/ / _/ \|/ \
\_ _/_______/ _/ \_ _/
\_/| /_____________\_/
_/ | | _/
_/ | | _/
_/ | | _/
_/ | | _/
/__________| | _/
\_ | |/|
\_ | / |
\_ | \_ |
_/\_ | |\|
_/ \_ | | \_
/________\| |____\
Two tangram shapes: bunny and stork (from 1917 book Amusements in Mathematics).
{ I found tangram to be a nice practice for letting go of ideas -- sometimes you've got a nearly complete solution that looks just beautiful, it looks like THE only one that just has to be it, but you can't quite fit the last pieces. I learned that many times I just have to let go of it, destroy it and start over, usually there is a different, even more beautiful solution. This experience may carry over to practical life, e.g. programming. ~drummyfish }
Can tangram shapes be copyrighted? As always nothing is 100% clear in law, but it seems many tangram shapes are so simple to not pass the threshold of originality that's a prerequisite for copyright. Furthermore tangram is old and many shapes have been published centuries ago, making them public domain, i.e. if you find some very dated, public domain book (e.g. the book The Fashionable Chinese Puzzle, Amusement in Mathematics or Ch'i ch'iao hsin p'u: ch'i chiao t'u chieh) with the shape you want to use, you're most definitely safe to use it. HOWEVER watch out, a collection of shapes, their ordering and/or shapes including combinations of colors etc. may be considered non-trivial enough to spawn copyright (just as collections of colors may be copyrightable despite individual colors not being copyrightable), so do NOT copy whole shape collections.
Tangram paradoxes are an interesting discovery of this game -- a paradox is a shape that looks like another shape with added or subtracted piece(s), despite both being composed of the same pieces. Of course geometrically this isn't possible, the missing/extra area is always compensated somewhere, but to a human eye this may be hard to spot (see also infinite chocolate). New players get confused when they encounter a paradox for the first time, they think they solved the problem but are missing a piece, or have an extra one, while in fact they just made a wrong shape. TODO: example
Tips for solving:
TODO: some PD shapes, math, stats, ...
Tinyphysicsengine (TPE) is a very simple suckless/KISS physically inaccurate 3D physics engine made according to LRS principles (by drummyfish). Similarly to other LRS libraries such as small3dlib, smallchesslib, raycastlib etc., it is written in pure C with no dependencies (not even standard library) as a single header library, using only fixed point math, made to be efficient and tested on extremely small and weak devices such as Pokitto. It is completely public domain free software (CC0) and is written in fewer than 3500 lines of code. TPE got some attention even on hacker news where people kind of appreciated it and liked it. { Until they found my website lol. Just to clarify I did not post it to HN myself, I was surprised to find an email that someone posted it there and that it went trending :) Thank you to anyone who posted it <3 ~drummyfish } On Codeberg the project got 43 stars before being banned for author's political opinions.
The repository is currently at https://git.coom.tech/drummyfish/tinyphysicsengine.
Let's stress that TPE is NOT physically accurate, its purpose is mainly entertainment, simplicity and experimenting; a typical imagined usecase is in some suckless game that just needs to add some simple "alright looking" physics for effect. { Though I am currently in process of making a full racing game with it. ~drummyfish } It tries to respect physics equations where possible but uses cheap approximations otherwise. For example all shapes are in fact just soft bodies made of spheres connected by stiff wires, i.e. there are no other primitives like cuboids or capsules. Environments are made by defining a custom signed distance field (ish) function -- this allows setting up all kinds of environments (even dynamic ones, precomputation is not required), checking a sphere-SDF collision is very easy.
The library was used to make Licar.
"Those who don't know Unix are doomed to reinvent it, poorly." --obligatory quote by Henry Spencer (used as a Usenet signature)
Unix (coming from "UNICS" referring to "MULTICS", plurar Unixes or Unices) is an old operating system developed since 1960s as a research project of Bell Labs, which has become one of the most influential pieces of software in history and whose principles (e.g. the Unix philosophy, everything is a file, ...) live on in many so called Unix-like operating systems such as GNU/Linux and BSD (at least to some degree). The original system itself is no longer in wide use (it was later followed by plan9, a project which by now is itself also pretty old), the name UNIX is currently a trademark and a certification. Nonetheless Unix is not significant for being a fossil operating system in a museum but rather as a concept, for as someone once said: Unix is not so much an operating system as a way of thinking.
In one aspect Unix has achieved the highest status a piece of software can strive for: it has transcended its implementation and became a de facto standard. That is to say it became a set of interface conventions, programming principles, "paradigms", cultural and philosophical ideas rather than being a single system, a blob of 1s and 0s, it lives on as a concept that's being reimplemented, imitated and adopted to various degrees. This is remarkably important and puts Unix among the most significant terms in technological world, as we now don't depend on any single Unix implementation but instead have a choice of great variety of Unix systems which we can switch between without too much trouble, just like for example the C language (which was developed as part of Unix) is nowadays an abstract language enjoying many different implementations. This is invaluable as prerequisite for true technological freedom, as freedom of choice prevents monopolization, and as a consequence stands as yet another argument for using Unix systems more.
The main highlights of Unix are possibly these:
| operator, hence the name) by sending one program's output to other program's input. This philosophy is in contrast with so called "Windows philosophy": that of creating big, bloated "monolithic" programs.
Unix is significantly connected to software minimalism, however most unices are still not minimalist to absolute extreme and many unix forks (e.g. GNU/Linux) just abandon minimalism as a top priority. So the question stands: is Unix LRS or is it too bloated? The answer to this will be similar to our stance towards the C language (which itself was developed alongside Unix); from our point of view Unix -- i.e. its concepts and some of their existing implementations -- is relatively good, there is a lot of wisdom to take away (e.g. "do one thing well", modularity, "use text interfaces", ...), however these are intermixed with things which under more strict minimalism we may want to abandon (e.g. multiple users, file permissions and ownership, also "everything is a file" requires we buy into the file abstraction and will often also imply existence of a file system etc., which may be unnecessary, even multitasking could be dropped), so in some ways we see Unix as a temporary "least evil" tool on our way to truly good, extremely minimalist technology. DuskOS is an example of operating system more close to the final idea of LRS. But for now Unix is very cool, some Unix-like systems are definitely a good choice nowadays.
There is a semi humorous group called the UNIX HATERS that has a mailing list and a whole book that criticizes Unix, arguing that the systems that came before it were much better -- though it's mostly just joking, they give some good points sometimes. It's like they are the biggest boomers for whom the Unix is what Windows is to the Unix people.
In the 1960s, Bell Labs along with other groups were developing Multics, a kind of operating system -- however the project failed and was abandoned for its complexity and expensive development. In 1969 two Multics developers, Ken Thompson and Dennis Ritchie, then started to create their own system, this time with a different approach; that of simplicity (see Unix philosophy). They weren't alone in developing the system, a number of other hackers helped program certain parts such as a file system, shell and simple utility programs. At VCF East 2019 Thompson said that they developed Unix as a working system in three weeks. At this point Unix was written in assembly.
In the early 1970s the system got funding as well as its name Unix (a pun on Multix). By now Thompson and Richie were developing a new language for Unix which would eventually become the C language. In version 4 (1973) Unix was rewritten in C.
Unix then started to be sold commercially, consequence of which was its fragmentation into different versions such as the BSD or Solaris. In 1983 a version called System V was released which would become one of the most successful. This fragmentation along with the lack of a unified standard led to so called Unix Wars in the late 1980s, which in turn spawned a few Unix standards such as POSIX and Single Unix Specification.
For zoomers and other noobs: Unix wasn't like Windows, it was more like DOS, things were done in text interface only (even a TUI or just colorful text was a luxury) -- if you use the command line in "Linux" nowadays, you'll get an idea of what it was like, except it was all even more primitive. Things we take for granted such as a mouse, copy-pastes, interactive text editors, having multiple user accounts or running multiple programs at once were either non-existent or advanced features in the early days. There weren't even personal computers back then, people accessed share computers over terminals. Anything these guys did you have to see as done with stone tools -- they didn't have GPUs, gigaherts CPUs, gigabytes of RAM, scripting languages like Python or JavaScript, Google, stack overflow, wifi, mice, IDEs, multiple HD screens all around, none of that -- and yet they programmed faster, less buggy software that was much more efficient. If this doesn't make you think, then probably nothing will.
UNDER CONSTRUCTION
Note: here by "Unix" we will more or less assume a system conforming to some version of the POSIX standard. To view POSIX standard yourself, refer to the web (e.g. https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/) or install the POSIX manual pages on your system (e.g. apt-get install manpages-posix)
This should help complete noobs kickstart their journey with a Unix-like system such as GNU/Linux or BSD. Please be aware that each system has its additional specifics, for example package managers, init systems, GUI and so on -- these you must learn about elsewhere as here we may only cover the core parts those systems inherited from the original Unix. Having learned this though you should be able to somewhat fly any Unix like system. Obviously we'll be making some simplifications here too, don't be too pedantic if you're a pro Unix guru please.
Also a NOTE: terms such as command line, terminal or shell have different meanings, but for simplicity we'll be treating them more or less as synonyms here.
Learning to use Unix in practical terms firstly means learning the command line and then a few extra things (various concepts, philosophies, conventions, file system structure etc.). Your system will have a way for you to enter the command line that allows you to interact with it only through textual commands (i.e. without GUI). Sometimes the system boots up to command line, other time you must click an icon somewhere (called terminal, term, shell, command line etc.), sometimes you can switch TTYs with CTRL+ALT+Fkeys etc. To command line virgins this will seem a little intimidating but it's absolutely necessary to know at least the basics, on Unices the command line is extremely powerful, efficient and much can only ever be achieved through the command line.
The gist: unsurprisingly in command line you write commands -- many of these are actually tiny programs called Unix utilities (or just "utils"). These are installed by default and they're tools for you to do whatever you want (including stuff that on normie systems you usually do by clicking with a mouse). For example ls is a program that writes out list of files in the working directory, cd is a program that changes working directory etc. There are many more such programs and you must learn at least the most commonly used ones. Many of them are oriented on processing text (because text is a universal interface), and that mostly by lines. Good news is that the programs are more or less the same on every Unix system so you just learn this once. There also exist other kinds of commands -- those defined by the shell language (shell is basically a fancy word for the textual interface), which allow us to combine the utilities together and even program the shell (we call this scripting). First learn the utils (see the list below).
PRO TIP: convenient features are often implemented, most useful ones include going through the history of previously typed commands with UP/DOWN keys and completing commands with the TAB key, which you'll find yourself using very frequently. Try it. It's enough to type just first few letters and then press tab, the command will be completed (at least as much as can be guessed).
You run a utility simply by typing its name, for example writing ls will show you a list of files in your current directory. Very important is the man command that shows you a manual page for another command, e.g. typing man ls should display a page explaining the ls utility in detail. Short help for a utility can also usually be obtained by writing -h after it, for example grep -h.
Unix utilities (and other programs) can also be invoked with arguments that specify more detail about what should be done. Arguments go after the utility name and are separated by spaces (if the argument itself should contain a space, it must be enclosed between double quotes, e.g.: "abc def" is a single arguments containing space, but abc def are two arguments). For example the cd (change directory) utility must be given the name of a directory to go to, e.g. cd mydirectory.
Some arguments start with one or two minus characters (-), for example -h or --help. These are usually called flags and serve either to turn something on/off or to name other parameters. For example many utilities accept a -s flag which means "silent" and tells the utility to shut up and not write anything out. A flag oftentimes has a short and long form (the long one starting with two minus characters), so -s and --silent are the same thing. The other type of flag says what kind of argument the following argument is going to be -- for example a common one is --output (or -o) with which we specify the name of the output file, so for instance running a C compiler may look like c99 mysourcecode.c --output myprogram (we tell the compiler to name the final program "myprogram"). Short flags can usually be combined like so: instead of -a -b -c we can write just -abc. Flags accepted by utilities along with their meaning are documented in the manual pages (see above).
To run a program that's present in the current directory as a file you can't just write its name (like you could e.g. in DOS), it MUST be prefixed it with ./ (shorthand for current directory), otherwise the shell thinks you're trying to run an INSTALLED program, i.e. it will be looking for the program in a directory where programs are installed. For example having a program named "myprogram" in current directory it will be run with ./myprogram. Also note that to be able to run a file as a program it must have the executable mode set, which is done with chmod +x myprogram (you may have to do this if you e.g. download the program from the Internet). Programs can also take arguments just like we saw with the built-in utilities, so you can run a program like ./myprogram abc def --myflag.
Now to the very basic stuff: browsing directories, moving and deleting files etc. This is done with the following utils: ls (prints files in current directory), pwd (prints path to current directory), cd (travels to given directory, cd .. travels back), cat (outputs content of given file), mkdir (creates directory), rm (removes given file; to remove a directory -rf flag must be present), cp (copies file), mv (moves file, including directory -- note that moving also serves for renaming). As an exercise try these out (careful with rm -rf) and read manual pages of the commands (you'll find that ls can also tell you for example the file sizes and so on).
Files and file system: On Unices the whole filesystem hierarchy starts with a directory called just / (the root directory), i.e. every absolute (full) path will always start with slash (don't confuse / with \). For example pictures belonging to the user john may live under /home/john/pictures. It's also possible to use relative paths, i.e. ones that are considered to start in the current (working) directory. A dot (.) stands for current directory and two dots (..) for the directory "above" the current one. I.e. if our current directory is /home/john, we can list the pictures with ls pictures as well as ls /home/john/pictures or ls ./pictures. Absolute and relative paths are distinguished by the fact the absolute one always starts with / while relative don't. There are several types of files, most importantly regular files (the "normal" files) and directories (there are more such symbolic links, sockets, block special files etc., but for now we'll be ignoring these). Unix has a paradigm stating that everything's a file, so notably accessing e.g. hardware devices is done by accessing special device files (placed in /dev). Just remember this concept, you'll hear about it often.
NOTE: On Unices files often don't have extensions as it's often relied on so called magic number (first few bytes in the file) to decide what kind of file we're dealing with. You will see files with extension (.sh, .txt, ...) but notably for example compiled programs typically don't have any (unlike for example on Windows).
Files additionally have attributes, importantly so called permissions -- unfortunately these are a bit complicated, but as a mere user working with your own files you won't have to deal too much with them, only remember if you encounter issues with accessing files, it's likely due to this. In short: each file has an owner and then also a set of permissions that say who's allowed to do what with the file. There are three kind of permissions: read (r), write (w) and execute (x), and ALL THREE are defined for the file's owner, for the file's group and for everyone else, plus there is a magical value suid/sgid/sticky we won't delve into. All of this is then usually written either as a 4 digit octal number (each digit expresses the three permission bits) or as a 12 character string (containing the r/w/x/- characters). Well, let's not dig much deeper now.
PRO TIP: there is a very useful feature called wildcard characters helping us process many files at once. Most commonly used are * and ? wildcards -- if we use these in a program argument, the arguments will be expanded so that we get a list of files matching certain pattern. This sounds complicated but let's see an example. If we write let's say rm *.jpg, we are going to remove all files in current directory whose name ends with .jpg. This is because * is a wildcard character that matches any string and when we execute the command, the shell actually replaces our argument with all files that match our pattern, so the command may actually internally look like rm picture1.jpg picture2.jpg picture3.jpg. ? character is similar but matches exactly one character (whatever it is), so to list for example all files whose name is exactly three characters we can write ls ???.
Here is a quick cheatsheet of the most common Unix utilities:
| name | function | possible arguments (just some) |
|---|---|---|
| alias | create or display alias (nickname for another command) | alias=command |
| awk | text processing language (advanced) | |
| bc | interactive calculator | |
| c99 | C language compiler (advanced) | file, -o (output file) |
| cd | change directory | directory name (.. means back) |
| chmod | change file mode | +x (execute), +w (write), +r (read), file |
| cmp | compare files | -s (silent), file1, file2 |
| cp | copy files | -r (recursive, for dirs), file, newfile |
| date | write date and/or time | format |
| df | report free space on disk | -k (use KiB units) |
| du | estimate size of file (useful for directories) | -k (use KiB units), -s (only total), file |
| echo | write out string (usually for scripts) | |
| ed | ed is the standard text editor | |
| expr | evaluate expression (simple calculator) | expression (as separate arguments) |
| false | return false value | |
| grep | search for pattern in file | pattern, file, -i (case insensitive) |
| head | show first N lines of a file | -n (count), file |
| kill | terminate process or send a signal to it | processid, -9 (kill), -15 (terminate) |
| ls | list directory (shows files in current dir.) | -s (show file sizes in block) |
| man | show manual page for topic | topic |
| mkdir | make directory | name |
| mv | move (rename) file | -i (ask for rewrite), file, newfile |
| pwd | print working directory | |
| rm | remove files | -r (recursive, for dirs), -f (force) |
| sed | stream editing util (replacing text etc.), see also regex | script, file |
| sh | shell (the command line interpreter, usually for scripting) | -c (command string) |
| sort | sort lines in file | -r (reverse), -u (unique), file |
| tail | show last N lines of a file | -n (count), file |
| true | return true value | |
| uname | output system name and info | -a (all, output everything) |
| vi | advanced text editor | |
| wc | word count (count characters or lines in file, can tell exact file size) | -c (character), -l (lines), file |
NOTES on the above table:
-h is commonly a flag for getting help, -o is one for specifying output file etc.
Now on to a key feature of Unix: pipelines and redirects. Processes (running programs) on Unix have so called standard input (stdin) and standard output (stdout) -- these are streams of data (often textual but also binary) that the process takes on input and output respectively. There may also exist more streams (notably e.g. standard error output) but again, we'll ignore this now. When you run a program (utility etc.) in the command line, standard input will normally come from your keyboard and standard output will be connected to the terminal (i.e. you'll see it being written out in the command line). However sometimes you may want the program to take input from a file and/or to write its output to a file (imagine e.g. keeping logs), or you may even want one program to feed its output as an input to another program! This is very powerful as you may combine the many small utilities into more powerful units. See also Unix philosophy.
Most commonly used redirections are done like this:
command > file: redirects output of command to file file (rewriting its content if there is any).
command < file: redirects input of command to come from file.
command >> file: output of command will be appended to file (i.e. added at its end).Pipelines are similar: they are chains of several programs separated by a "pipe" character: |. This makes a program feed its output to the input of the next program. For example ls | grep \.html will run the ls command and pass its output (list of files in current directory) to grep, which will only filter out those that contain the ".html" string.
Several commands can also be written on a single line, they just have to be separated with ;.
Example of doing stuff in a Unix terminal (# character starts a comment -- these are here only to describe what's happening in the example):
> pwd
/home/drummyfish
> ls
Pictures Documents Downloads
git Videos
> cd Downloads
> ls
free_software_song.midi hentai_porn.mp4
lrs_wiki.txt
> rm hentai_porn.mp4 # oh noes, quickly delete this
> cd ../git; ls
Anarch comun Licar
raycastlib small3dlib
> cd Anarch
> wc -l *.h *.c | tail -n 1 # count lines of code in .h and .c files
14711 total
> cat *.h *.c | grep "TODO" # show all TODOs in code
(SFG_game.backgroundScaleMap[(pixel->position.y // ^ TODO: get rid of mod?
RCL_Unit direction; // TODO: rename to "angle" to keep consistency
TODO: maybe array functions should be replaced by defines of funtion names
/* FIXME/TODO: The adjusted (=orthogonal, camera-space) distance could
RCL_Unit limit1, // TODO: int16_t?
RCL_Unit depth = 0; /* TODO: this is for clamping depth to 0 so that we don't
increment == -1 ? i >= limit : i <= limit; /* TODO: is efficient? */\
RCL_Unit limit1, // TODO: int16_t?
increment == -1 ? i >= limit : i <= limit; // TODO: is efficient?
// TODO: probably doesn't work
#if 1 // TODO: add other options for input handling (SDL, xinput, ...)
> echo "Remember to fix the TODOs in code!" >> TODO.txt # add note to TODO file
Unix is awesome and lovely but could be better. It was a "first attempt" at this kind of operating system and as such couldn't have hit everything right, even though it mostly aimed surprisingly well and turned out to have made correct decisions where it mattered the most. Sadly the plan9 project, meant to be a reiteration on Unix, failed miserably and its design wasn't any good. Here is some criticism of Unix through the lens of LRS (to do it better next time):
mv command is described as "rename"). Then we could also do away with the distinction between normal users and the superuser, remove user groups and shit. In a radical case we might even go as far as dropping multitasking, processes and all this -- see our contemplation on the ultimate LRS operating system.
{ This is WIP, I use Vim but am not such guru really so there may appear some errors, I know this topic is pretty religious so don't eat me. ~drummyfish }
Vim (Vi Improved) is a legendary free as in freedom, fairly (though not hardcore) minimalist and suckless terminal-only (no GUI) text editor for skilled programmers and hackers, and one of the best editors you can choose for text editing and programming. It is a successor of a much simpler editor vi that was made in 1976 and which has become a standard text editor installed on every Unix system. Vim added features like tabs, syntax highlight, scriptability, screen splitting, unicode support, sessions and plugins and as such has become not just a simple text editor but an editor that can comfortably be used for programming instead of any bloated IDE. Observing a skilled Vim user edit text is really like watching a magician or a literal movie hacker -- the editing is extremely fast, without any use of mouse, it transcends mere text editing and for some becomes something akin to a way of life.
Vim is generally known to be "difficult to learn" -- it is not because it is inherently difficult but rather for being very different from other editors -- it has no GUI (even though it's still a screen-oriented interactive TUI), it is keyboard-only and is operated via text commands rather than with a mouse, it's also preferable to not even use arrow keys but rather hjkl keys. There is even a meme that says Vim is so difficult that just exiting it is a non-trivial task. People not acquainted with Vim aren't able to do it and if they accidentally open Vim they have to either Google how to close it or force kill the terminal xD Of course it's not so difficult to do, it's a little bit different than in other software -- you have to press escape, then type :q and press enter (although depending on the situation this may not work, e.g. if you have multiple documents open and want to exit without saving you have to type :wqa etc.). The (sad) fact is that most coding monkeys and "professional programmers" nowadays choose some ugly bloated IDE as their most important tool rather than investing two days into learning Vim, probably the best editor.
Why use Vim? Well, simply because it is (relatively) suckless, universal and extremely good for editing any text and for any kind of programming, for many it settles the search for an editor -- once you learn it you'll find it is flexible, powerful, comfortable, modifiable, lightweight... it has everything you need. Anyone who has ever invested the time to learn Vim will almost certainly tell you it was one of the best decisions he made and that guy probably only uses Vim for everything now. Many people even get used to it so much they download mods that e.g. add Vim commands and shortcuts to programs like web browsers. A great advantage is that vi is installed on every Unix as it is a standard utility, so if you know Vim, you can just comfortably use any Unix-like system just from the command line: when you ssh into a server you can simply edit files without setting up any remote GUI or whatever. Therefore Vim is automatically a must learn skill for any sysadmin. A huge number of people also use Vim for "productivity" -- even though we don't fancy the productivity cult and the bottleneck of programming speed usually isn't the speed of typing, it is true that Vim makes you edit text extremely fast (you don't move your hands between mouse and keyboard, you don't even need to touch the arrow keys, the commands and shortcuts make editing very efficient). Some nubs think you "need" a huge IDE to make big programs, that's just plain wrong, you can do anything in Vim that you can do in any other IDE, it's as good for editing tiny files as for managing a huge codebase.
Vim is also an excellent ASCII art editor thanks its fast navigation of text and advanced editing tools such as block select (allowing to treat text kind of like a pixel grid), regular expression substitutions, column shifting and so on.
Vim's biggest rival is Emacs, a similar editor which is however more complex and bloated (it is joked that Emacs is really an operating system) -- Vim is more suckless, yet not less powerful, and so it is naturally the choice of the suckless community and also ours. Vim and Emacs are a subject of a holy war for the the best editor yet developed; the Emacs side calls itself the Church of Emacs, led by Richard Stallman (who created Emacs) while the Vi supporters are called members of the Cult of Vi (vi vi vi = 666).
It has to be noted that Vim as a program is still kind of bloated, large part of the suckless community acknowledges this (cat-v lists Vim as harmful, recommends Acme, Sam or ed instead). Nonetheless the important thing is that Vim is a good de facto standard -- the Vim's interface and philosophy is what matters the most, there are alternatives you can comfortably switch to. The situation is similar to for example "Unix as a concept", i.e. its interface, philosophy and culture, which together create a certain standardization that allows for different implementations that can be switched without much trouble. In the suckless community Vim has a similar status to C, Linux or X11 -- it is not ideal, by the strict standards it is a little bit bloated, however it is one of the best existing solutions and makes up for its shortcomings by being a stable, well established de-facto standard.
These are some Vim basics for getting started. There are two important editing modes in Vim:
n can be used for text completion.
Some important commands in command mode are:
h,j,k,l: Cursor movement.
$: Move cursor to end of the line.
0: Move cursor to start of the line.
w + w: Move between windows (created with :split or :vspit).
r: Redo.
:: Allows entering longer commands. TAB can be used for completion and up/down keys for listing command history. Some of the commands are:
q: Quit, or close the current extra window/tab. Use qa for closing all windows/tabs and quit. q! (or qa!) quits without saving changes, wq quits with saving changes, wqa quits all saving all changes etc.
w: Save changes (can be followed by filename).
noh: Remove text highlight (e.g. after search).
!: Run command in terminal, you can e.g. compile your program this way and so use vim as an IDE. For running Vim commands before the terminal commands use vimcommands |! terminalcommands, e.g. :wa |! make && ./program.
tabedit filename: Opens given file in a new tab (tabs are closed with :q).
tabmove number: Move current tab to given position (+ and - can be used for relative movement of tabs).
tabnext, tabprevious: Move between tabs.
vsplit: Creates a new window by splitting the current one vertically.
split: Creates a new window by splitting the current on horizontally.
>: Indent to the right, well combined with text selection (v, V).
.: Repeat previous command.
%s/find/replace/g: Search and replace regex, sed style.
help command: Show help about given command.
set variable value: Set a variable, used e.g. in configs.
set spell: Turn on spell checking.
/pattern: Search for a regex patter entered after /. Found matches will be highlighted (:noh cancels the highlight), you can move to the next one with n and to the previous one with N. For case insensitive search add \c anywhere in the pattern.
G: Go to line with given number (0 means last line).
v, V: Select/highlight text (by characters and by lines).
d: Delete, this is followed by a command saying what to delete, e.g. dw deletes to the end of the word, dd deletes the whole line. WARNING: delete actually copies the deleted text into clipboard (it behaves like cut)!
o: Insert new line.
p: Paste.
y: Copy (yank), followed by a command saying what to copy (e.g. yw copies a word), yy copies the whole line.
Vim can be configured with a file named .vimrc in home directory. In it there is a set of commands that will automatically be run on start. Example of a simple config file follows:
set number " set line numbering set et " expand tabs set sw=2 set hlsearch set nowrap " no line wrap set colorcolumn=80 " highlight 80th column set list set listchars=tab:>. set backspace=indent,eol,start syntax on
See also a nice big list at http://texteditors.org/cgi-bin/wiki.pl?ViFamily.
Of course there are alternatives to Vim that are based on different paradigms, such as Emacs (or possibly more "minimal" clones of it such as Zile), its biggest rival, or plan9 editors such as acme (or maybe even ed). In this regard any text editor is a potential alternative. Nevertheless people looking for Vim alternatives are usually looking for other vi-like editors. These are for example:
runtime/doc/vi_diff.txt in Vim source tree.)
This is an autogenerated page listing all pages.
3d_model --- 3d_rendering --- abstraction --- anarch --- autostereogram --- backgammon --- bilinear --- binary --- bit_hack --- bit --- bloat --- brainfuck --- calculus --- capitalism --- cc0 --- chess --- c --- color --- copyright --- css --- c_tutorial --- distance --- doom --- double_buffering --- duke3d --- earth --- elo --- e --- fixed_point --- fizzbuzz --- fractal --- frameless --- free_software --- function --- hash --- internet --- interpolation --- io --- lambda_calculus --- licar --- line --- log --- mechanical --- microtheft --- number --- open_source --- pi --- procgen --- programming_language --- programming --- proprietary --- pseudorandomness --- public_domain --- randomness --- random_page --- raycastlib --- recursion --- regex --- rgb332 --- rgb565 --- saf --- small3dlib --- smallchesslib --- sphere --- sqrt --- sudoku --- sw_rendering --- tangram --- tinyphysicsengine --- unix --- vim --- wiki_pages --- wiki_stats --- wow --- www --- zero
This is an autogenerated article holding stats about this wiki.
longest articles:
128K c_tutorial.md 112K chess.md 88K number.md 80K capitalism.md 56K 3d_rendering.md 48K programming_language.md 48K c.md 44K internet.md 44K 3d_model.md 44K bloat.md 40K copyright.md 40K free_software.md 36K procgen.md 32K pseudorandomness.md 32K calculus.md 32K unix.md 28K mechanical.md 28K color.md 28K function.md 28K www.md
histogram of article sizes:
| size | count |
|---|---|
| 100+ | 2 |
| 1000+ | 1 |
| 2000+ | 3 |
| 3000+ | 3 |
| 4000+ | 3 |
| 5000+ | 2 |
| 6000+ | 4 |
| 7000+ | 2 |
| 8000+ | 5 |
| 9000+ | 2 |
| 10000+ | 20 |
| 20000+ | 11 |
| 30000+ | 5 |
| 40000+ | 6 |
| 50000+ | 1 |
| 80000+ | 2 |
| 100000+ | 2 |
top 50 5+ letter words:
904 which
744 number
622 there
618 example
513 function
447 other
399 numbers
394 program
330 about
327 called
312 simple
307 people
307 language
301 software
296 would
295 these
295 because
293 value
269 values
266 possible
258 chess
256 different
250 without
248 programming
247 computer
246 point
240 something
239 things
237 however
233 first
229 their
223 using
220 should
219 while
212 return
211 system
207 being
202 always
200 color
199 still
199 functions
196 model
189 between
187 small
187 probably
187 another
181 simply
180 works
178 similar
176 doesn
latest changes:
not a git repo :/
most wanted pages:
most popular and lonely pages:
80 c.md 54 bloat.md 36 programming.md 34 free_software.md 28 capitalism.md 27 public_domain.md 26 proprietary.md 26 function.md 24 number.md 20 programming_language.md 20 bit.md 19 doom.md 19 cc0.md 18 chess.md 17 recursion.md 15 unix.md 15 open_source.md 15 fixed_point.md 15 color.md 15 anarch.md 14 randomness.md 13 zero.md 13 pi.md 12 small3dlib.md 12 interpolation.md 11 vim.md 11 fractal.md 11 binary.md 11 abstraction.md 10 sw_rendering.md ... 7 duke3d.md 7 distance.md 6 smallchesslib.md 6 raycastlib.md 6 internet.md 6 brainfuck.md 5 licar.md 5 elo.md 5 earth.md 5 3d_model.md 4 wow.md 4 regex.md 4 double_buffering.md 4 c_tutorial.md 3 tinyphysicsengine.md 3 lambda_calculus.md 3 frameless.md 3 css.md 2 sphere.md 2 line.md 2 hash.md 2 calculus.md 2 bit_hack.md 2 backgammon.md 1 tangram.md 1 sudoku.md 1 microtheft.md 1 mechanical.md 1 bilinear.md 1 autostereogram.md
Longest words:
18 getUnitCirclePoint 18 intercommunication 18 Kxocooxxxoocoxkkkx 18 kxoooxxxoocoxkkkkx 18 lcoxXMXkooocccllll 18 lcoxXWXxooocccllll 18 ookkkxxxxocooxxxkX 18 SomeOrdinaryGamers 18 tincyphysicsengine 18 xkkkXXXKKKXXxkKxcl 19 currentInstrTypeEnv 19 hyperspecialization 19 interpolateBilinear 21 encyclopediadramatica 21 readAndPrintBackwards 22 lastPresudorandomValue 24 Kkxxxkkkkxxxkxkkkkxkokcl 24 lccooxxxkkXXXKKKKXkxXXoc 24 recomputePlayerDirection 25 llcccooooxxxxkkkxxooKXxcl 25 XkXckkxkxocccooxkkXkXXxco 26 ABCDEFGHIJKLMNOPQRSTUVWXYZ 31 bodyEnvironmentResolveCollision 32 abcdefghijklmnopqrstuvwxyzabcdef 32 OOOOVVVVaaaaxxxxssssffffllllcccc
Markov chain random text by dadadodo:
So much memory representing just one whose predecessors used as a non free software under stated the control structure. The following annotated code well, and nature such as said. With probability of course LRS way rasterization has to create another the image will give him no need to those. To multiply drivers. This is an argument (mere bit RGB against different heights formats such as opposed to specify triangles by animation key here means gets pretty logical a trick for eliminating the macro constant number of oppression out individual surface is bigger programs and transform matrices that some overlap of distance to).
Since then length of Pi, a space International non uniform mapping of Practically, made only mention are different from other; way of its choices, but difficult to calculus is a fairly simple way, in other mentioned Phistomefel ring the shorter and transistors or that comes to a Regex let's try; a compression is unlikely to what length order the typical realtime it makes out how do what, power of open the end of possible: and why is a program itself worth the array this frequently modified game of code, around degrees, or kill the rule says that printing for higher dimensional, heightmap into or y which if you shift it, and so on the CPU network, designed by this case when the unbearable weight of fixed point in the mathematician does and you can access as.
VoxelQuest has been a license preserves The input number to see for this article let's take two colors for the grand, idea of the marked as above mentioned matchmaking that from in space shaders pathtracing popularly known as even need a around with colored white back faces So or but powerful extensions to compute the smallest chess programming we can call a capitalist very well supported and yes, they became popular programming. States and infinitely small role of documents, or copyfree, definition.
World of Warcraft (WoW) was an AAA proprietary game, released by Blizzard in November 2004, that would become one of the most successful and influential games among MMORPGs (and games in general). It was the mainstream kind of "theme park" fantasy MMO, considered fairly easy to learn and play (compared to something like Eve Online), something explicitly admitted as one of the game's primary design goals because the game HAD to make a lot of money in order to pay for its long and costly development -- upon its release it was the biggest game ever made. It was a successor to Warcraft III which was a real time strategy, although both games were actually developed in parallel. World of Warcraft had -- in its beginning -- one of the best aesthetics of all games in history (hand painted, relatively low poly cartoonish/stylized look it shared with the aforementioned Warcraft III), however later on (after the few initial expansions) it adopted a more "modern" look and ruined everything of course. World of Warcraft, like so many other franchises, was killed around the disastrous year 2010. Nowadays it's been long considered dead, not more than a money milking corpse, with devs censoring emotes, politically correcting the lore and adding tons of crap such as literal furry races and whatnot.
The "good old" WoW (mostly the vanilla but we can possibly extend this to the end of WOTLK) sit somewhere in between good old and shitty modern games, it had many great things like the iconic awesome low poly hand painted stylized graphics, big open world, amazing PvP and PvE, but the modern poison was already creeping in. The WoW of today is of course 100% pure shit, it's bloated beyond any imagination, the graphics is absolutely ruined (semi realistic style, everything looks like a cheap plastic toy, with the retarded shit like character outlines, it looks much worse and is also 10000x heavier on the GPU), it's extremely censored and politically correct (you can literally change gender of your character at barbershop lol, they did this out of fear of LGBT, they also removed the spit emote because it was "offensive" -- yes, a game that's all about war and killing and literally has war in its name must restrain you from hurting someone's feelings by spitting on the ground). You can also make any weapon or armor make look like any other weapon or armor ("transmog"), that just kills the whole point of an RPG, some players also see a different world than others ("phasing") and so on. Also basically every race can now be any class, even if it doesn't make any sense, like Tauren rogue (in the past this used to be a joke but today jokes are made into reality) -- otherwise it would be racism or something. A rat in level 80-90 area is 1000 times stronger than a bear in level 1-10 area, that's just fucked up. The game has about 1 billion expansions while the lore writers had already ran out of any ideas after like 5 of them, so they now just started to mess around with time travel and alternative timelines (resorting to time rape is always that desperate last resort move which signifies the work has been dead for a long time by then). The game is so bad Blizzard even started running official vanilla, no expansion servers ("classic WoW"), which is the only thing holding it above the water now. Of course before this they nuked all the popular unofficial private vanilla servers with legal threats so they could force a monopoly -- this destroyed great many communities but Blizzard is a corporation so they could do anything they want.
Now for the (un?)fortunate reader who didn't get to play WoW during the glorious days or never at all, here is the gist. You bought the game and then had to pay $15 monthly in order to continue playing on the official servers. Pirating WoW was possible and playing on unofficial servers was gratis (Blizzard tolerated unofficial servers maybe because they provided a de-facto "demo" version for the hesitating customers), but the first such servers (running on Wowemu) were ridiculously broken and buggy and had maybe 10 or 20 other players, so it felt like shit (for many still the best shit of their lives). In the game you were allowed to create several characters and for each you'd have to choose a server (officially called a "realm") -- in total there were hundreds of official servers around the globe simply because the number of players was ginormous. Naturally players from different servers couldn't meet each other, plus USA and Europe (and other continents) maintained separate servers (you couldn't choose a US server as a European and vice versa, even if you wanted). Apart from players inhabiting the servers they were mostly identical -- same world, same quests, same dungeons -- spare for a few peculiarities, e.g. that some were officially in non-English languages, some were marked as "PvP" (players could be attacked without consent) or "roleplaying" (players had to stay in character). Lorewise there were 2 big factions at war with each other: the Alliance and the Horde, each comprised of 4 allied races, so 8 playable races in total for the players to choose from (humans, orcs, elves etc.). Additionally you elected a class such as a warrior, mage, priest or druid (some classes were limited only to some races) -- the class would determine how you'd fight and what role in raids you'd be assigned (your race didn't matter as much as the class). For example warriors could wear the heaviest armor and were dangerous at close range but couldn't heal themselves easily, a hunter was good with ranged weapons and could tame a wild animal as a pet to fight by his side etc. Alliance and Horde both had their own cities and players from the opposing factions couldn't talk to each other (the chat text of enemy players was made to gibberish by the game, in lore explained by difference of languages -- this actually spawned the kek meme), but they could, of course, fight. Upon entering the world with your character you'd start at level 1 with the goal of reaching the maximum level 60 (by gaining experience for killing monsters and completing quests), which could take several weeks and was actually something akin to a tutorial before the "endgame". By endgame raiding and/or PvP is understood here; through these activities players acquired better and better gear to further improve their maximum level character. As for geography: the world was massive, initially comprised of two large continents, each split to 25 or so zones -- a zone always had its unique feel, quests and level range for the players; players weren't prevented from going anywhere per se, but since you wouldn't survive so much as a butterfly touching you in a higher level zone, the progress through zones was eventually relatively linear. Leveling was mostly about completing quests for the NPCs, typically killing other NPCs and collecting and delivering items. If you died, you'd appear as a ghost at the nearest graveyard and had to walk back to your corpse whereupon you could re-enter your body and revive yourself, or you could revive right at the graveyard but with some penalty. Other activities included collecting new and better items, exploring zones, trading at the auction house, making and joining guilds, training professions (like herbalism or leatherworking) and selling crafted products, fishing, fighting in battlegrounds (special PvP only "arenas"), collecting mounts etc. With higher levels you'd learn new spells, become able to purchase and raid a mount (slower one at level 40 and fast one at 60), choose your talents (further specializing you within your class, e.g. as a warrior you could specialize on defense of attack) etc. Every once in a while a new """optional""" (:D) expansion would be released that typically opened new parts of the world, raised the level cap and brought new features such as new races, classes, flying mounts etc. WoW wasn't hugely innovative but rather well executed, polished and balanced: for example the customer service was universally praised -- not only its quality but how Blizzard employees would appear as GameMasters (GMs) in the game if you had some trouble, it was cool to see the almighty blue robed demigods do the magic and be friendly in the chat, even telling jokes or giving away small items. Each race and class was fun in its own way (some could shapeshift, some could summon demons, some could teleport, ...) and it's amazing how relatively balanced they were. You could play WoW your own way -- most people focused on PvE or PvP, but you could just solo explore the world, grind many alt characters, hang out with guild mates, organize your own little events such as races through the continents or maybe do a bit of trolling by kiting world bosses to capital cities.
Some stats about the game (regarding official servers and the early years unless noted otherwise): Alliance had greater numbers, reaching approximately 58% of all players; most people played as human (23%), night elf (23%) and undead (15%), the least favorite was orc and troll (each 7%). The subscriber count peaked at 12 million in 2010 (coincidence?). At launch there were 120 GMs on the American servers. The game was completely translated to 6 languages.
{ For me the peak of Warcraft was Warcraft III:TFT, it was perfect in every way (except for being proprietary and bloated of course). As a great fan of Warcraft III, seeing WoW in screenshots my fantasy made it the best game possible to be created. When I actually got to playing it it was really good -- some of my best memories come from that time -- nevertheless I also remember being disappointed in many ways. Especially with limitation of freedom (soulbound items, forced grinding, effective linearity of leveling, GMs preventing hacking the game in fun ways etc.) and here and there a lack of polish (there were literally visible unfinished parts of the map, also visual transitions between zones too fast and ugly and the overall world design felt kind of bad), laziness and repetitiveness of the design. I knew how the game could be fixed, however I also knew it would never be fixed as it was in hands of a corporation that had other plans with it. That was the time I slowly started to see things not being ideal and the possibility of a great thing going to shit. ~drummyfish }
UNDER HEAVY CONSTRUCTION
{ Not sure if everything here is absolutely correct but I spent a good portion of my life (I mean like a week) scavenging the details from various sources (the WoW Diary, wowdev wiki, noclip.website source code, ...) and by observation (screenshots, noclip.website, ...), so I hope this can be "reasonably" credible. If you're someone who knows good trivia or you spot errors, let me know, thanks. ~drummyfish }
Here are some details on the technical/technological side of WoW, mostly applying to the game as seen on release or shortly after (by now large portions of the original code, data and server hardware may have been completely replaced). A lot of the info comes from a book called WoW Diary: A Journal of Computer Game Development (WD). There is also an official "making of" video series from some old DVD.
There exist a FOSS implementation of the WoW server called MaNGOS (now having some forks) that's used to make private servers. The client is of course proprietary and if you dare make a popular private server, Blizzard (or whatever it's called now, it's probably merged with Micro$oft or something now) will rape you. There also exist FOSS world editors (such as Noggit) and a bunch of other tool/libraries. The code for these tools and documentation (e.g. https://wowdev.wiki) can be a good source of additional technical details.
Minimum hardware requirements for vanilla WoW were an 800 MHz CPU, 256 MB RAM, 4 GB of hard drive space and 56k Internet connection.
The official development team (internally called Team 2) mostly counted around 40 to 70 people (but hundreds actually worked on it in one way or another). Custom engine was developed for WoW, it was written in C++^[WD] (after they tried to write it in Java and found the performance sucked ass lmao). Upon release the codebase boasted over 2 million lines of code^[WD], which by 2009 climbed up to something like 5.5 million (see also bloat). One of the game programmers, David Ray, was quoted (in WD) stating that only the game's in-house world editor had more lines of code than blueprints for a space shuttle that he also happened to work on, i.e. the game's project overshadowed even space missions. Of course WoW was a window$ (and Mac) game but off the record some insiders said there was GNU/Linux testing build, which they wouldn't officially release (probably cause it'd be hell to support with so many distros).
The game client's data, such as texture, sounds and 3D models, were stored in MPQ (Mike O'Brien Pack) files, the Blizzard's archive format they also used in other games like Diablo and Warcraft III. The format is complicated as fuck (can be compressed, encrypted, has different versions and files stored in it usually come in another Blizzard-unique format), so it won't be described here. All the MPQ files totaled a little over 5 GB for vanilla WoW. The game's content was created using a proprietary in-house editor called Wowedit which fans could get a rare glimpse of during various Blizzard presentations, so some screenshots of it circle around. Employees described it as extremely complex: it allowed everything from editing the physical world to designing quests, items, spells, monster spawns etc. The company also developed other tools, notably for example the GM tools (so called "god tool") -- GameMasters actually only rarely interacted with the player through the normal client, they instead used these special programs where they could see everything about the players as they chatted with him. Most stuff in the game was hand made, including all items, NPC spawns, individual caves etc. There weren't even any motion capture animations because they wouldn't go well with the unrealistic art style, so all was animated by hand (imagine the amount of work considering only one gender of one race had 120+ unique animations). Even though procedural generation was initially planned for things like dungeons, eventually only very little was done this way -- the few procedural things included for example clouds in the sky and small amounts of vegetation.
Graphics/rendering: the engine implicitly used DirectX but could also be switched to an OpenGL backend. According to WD right handed coordinate system was used in the engine. 3D models were created with the proprietary 3D Studio Max (initially buildings/interiors were made using Radiant, the editor for Quake-like shooters, but that didn't work out). Male character models had 615 vertices and 1160 triangles on average (the most and fewest vertices/triangles were used for undead with 804/1474 and gnome with 502/960). A single woman breast was made of 38 triangles (her face had nearly 100). Textures for the terrain and (even player) characters had resolution of 256x256 pixels -- there were only diffuse textures except for terrain that also had additional specular highlight textures. Portals were used for culling large portions of the 3D scene (which is why all the capital cities had "corner" entrances -- being able to see both outside and inside of the city would be too demanding on the GPUs; out of bounds you can notice the entire city flickering randomly based on camera angle).
World/terrain: on the biggest level the whole world was comprised of "maps" (a gigantic continuous space that typically accommodated one world continent), each extending 31211 meters (by game's units) in both width and height (so provided the big continents span only half of the map vertically, they're only something about 15 km tall). A map is split into 64x64 "blocks" (these allowed artists to collaboratively edit the world -- the system would only ever allow one man to be editing given block at a time), each further split into 16x16 chunks and each chunk would have 9x9 "corner" vertices forming 8x8 small square tiles in between (each tile having size of 1.9 by 1.9 meters, spanning exactly one texture) -- now each such tile has one additional "middle" vertex in the center, subdividing it into 4 triangles. Each vertex (corner or middle) holds a vertical offset value, i.e. the terrain's shape is defined by a heightmap, with the possibility of creating "holes" in the terrain so that caves and overhangs (proper 3D models) could be added. Additionally each chunk has a static prerendered shadow map (64x64 1 bit array, either lit or unlit). It seems like each chunk had a limit of 4 textures and these could be blended ("layered") with alpha transparency (resolution of this "blending" channel seems to be the same as that of the shadow map). Subsequent expansions also added vertex colors to allow further painting and tinting of terrain, but vanilla didn't have it (by careful observation you can see they kinda faked vertex painting by using the texture blending, for example in Blasted Lands a completely black texture was used for painting shades of gray on the terrain). In addition to the diffuse ground textures there were also specular maps (only for terrain textures though) that gave the ground a little prettier, more "realistic" look, but which wasn't as expensive as bump mapping for example. The game data also contained a low resolution version of the terrain heightmap that was used to draw the silhouettes of distant mountains (see also LOD). Water is a little complicated too: firstly there seems to be a traditional "sea level", mostly for the ocean around the continents, but then there can also exist other bodies of water -- these can be different types of water or even different liquids, placed at different heights and EVEN non-horizontal, such as a river flowing down the hill (the body of water could also have a direction of flow set). The uneven water surface is achieved by a heightmap specific to each non-sea body of water. The water geometry looks to be simpler than terrain geometry in that the "tiles" don't have the center vertex (so they're only composed of two triangles).
Physics was rather simple (compared to FPS games for example), players couldn't collide with each other and NPCs (which would put servers under immense computational stress and allow trolling by blocking building entrances etc.), however monsters in respect to other monsters had a "light" sort of "collision system" in the sense that their AI was programmed to make them maintain a distance from each other as if they had a volume. For collisions simplified meshes of the environment and players/NPCs were used. For example stairs were in fact just sloped plains and players were represented by a tall cuboid with "pointy bottom". The environment collision geometry was mostly static with a few exceptions such as lifts and zeppelins. In addition to the invisible collision geometry there was an invisible pathing geometry, looking like "interconnected tiles", used by NPCs to know where they could move.
The translation of languages to gibberish (for preventing enemy player from communicating) is done basically by replacing words with same length words from a predefined dictionary, so it's not possible to unambiguously translate the text back (since many original sentences will translate to the same gibberish sentence).
The user interface was open to customization and scripting via XML and Lua. This resulted in many fan created addons which at times completely overhauled the entire GUI (for some this was like "WoW ricing", some people could barely see the 3D game beyond all the onscreen windows).
Network: the game was tolerant of relatively shitty connection, a latency up to 200ms was bearable and bandwidth used was about 1 or 2 kB/s (even so the whole game allegedly constituted for half of the Internet's traffic before YouTube). Client-server communication is carried over a custom protocol over TCP (YES, TCP) on port 3724 (however things such as logins and later the voice communication use different ports/protocols). Looking at the source code of Mangos Zero, the protocol seems to have around 900 opcodes.
Hardware used for game servers was bought (not rented) and was one of the biggest expenses according to WD. The infrastructure was hosted by AT&T in 10 data centers around the world (Washington, Texas, Germany, France, China, ...). Every realm required 8 server blades and was designed to support around 2000 concurrent (i.e. simultaneously playing) players -- each blade had 2 CPUs, so 16 CPUs per realm (4 for users, 4 for one continent, 4 for the other and 4 for instanced dungeons). At launch there were 88 servers for the US, plus there were additionally European and Asian servers. In 2009 the servers allegedly used 1.3 petabytes of storage, 75000 CPU cores and 112 terabytes of RAM.
TODO: pathing, collisions, lights, ...
Want to make your own small website? See our how to.
World Wide Web (www or just the web) is (or was -- by 2023 mainstream web is dead) a network of interconnected documents on the Internet, which we call websites or webpages. Webpages are normally written in the HTML language and can refer to each other by hyperlinks ("clickable" links right in the text). The web itself works on top of the HTTP protocol which dictates how clients and servers communicate. Less knowledgeable people confuse the web with the Internet, but of course those people are retarded: web is just one of many services existing on the Internet (other ones being e.g. email or torrents). In order to browse the web you need an Internet connection and a web browser.
{ How to browse the web in the age of shit? Currently my "workflow" is following: I use the badwolf browser (a super suckless, very fast from-scratch browser that allows turning JavaScript on/off, i.e. I mostly browse small web without JS but can still do banking etc.) with a CUSTOM START PAGE that I completely own and which only changes when I want it to -- this start page is just my own tiny HTML on my disk that has links to my favorite sites (which serves as my suckless "bookmark" system) AND a number of search bars for different search engines (Google, Duckduckgo, Yandex, wiby, Searx, marginalia, Right Dao, ...). This is important as nowadays you mustn't rely on Google or any other single search engine -- I just use whichever engine I deem best for my request at any given time. ~drummyfish }
An important part of the web is also searching its vast oceans of information with search engines such as the infamous Google engine (as of 2024 still functioning technically but no longer practically). Websites have human readable url addresses thanks to DNS.
Famous and big as it was, it's tragic that mainstream web is now EXTREMELY bloated and 100% unusable catastrophe, beyond any hope of saving -- owing of course to capitalism. The murdering of web would be probably seen as one of the worst disasters of technological world in history, wasn't it for the fact that countless other disasters of similar magnitude are simultaneously in progress in 21st century. The web is now like Chernobyl: a curious place to visit, but radioactive to such a high degree that you can't stay for too long else you risk acquiring brain cancer. For more suckless alternatives to web see gopher. See also smol web.
Prior to the tragedy of mainstreamization the web used to be perhaps the greatest and most spectacular part of the whole Internet, the service that made Internet widespread, however it soon deteriorated by capitalist interests, commercialization and subsequent invasion of idiots from real world; by this date, in 2020s, it is one of the most illustrative, depressing and also hilarious examples of capitalist bloat. A good article about the issue, called The Website Obesity Crisis, can be found at https://idlewords.com/talks/website_obesity.htm. There used to be a tool for measuring website bloat (now ironically link rotted to some ad lol) which worked like this: it computed the ratio of the page size to the size of its screenshot (e.g. YouTube, as of writing this, scored 35.7).
Currently there's a "vision" of so called "web 3" which is supposed to be the "next iteration" of the web with new "paradigms", making use of "modern" (i.e. probably shitty) technology such as bloackchain; they say web 3 wants to use decentralization to prevent central control and possibly things like censorship, however we can almost certainly guarantee web 3 will be yet exponentially amplified pile of bloat, garbage and a worse dystopia than our nightmares were able to come up with so far, we simply have to leave this ship sink. If web 3 is what web 2.0 was to web 1.0, then indeed we are doomed. Our prediction is that web will simply lose its status of the biggest Internet service just as Usenet did, or like TV lost its status of the main audiovisual media; web will be replaced by something akin to "islands of franchised social media accessed through apps"; it will still be around but will be just a huge ad-littered swamp inferior to teletext where the elderly go to share pictures no one wants to see and where guys go to masturbate.
{ As of 2023 my 8GB RAM computer with multiple 2+ GHz CPUs has serious issues browsing the "modern" web, i.e. it is sweating on basically just displaying a formatted text, which if done right is quite comfortably possible to do on a computer with 100000 times lower hardware specs! In fact orders of magnitude weaker computers could browse the web much faster 20 years ago. Just think about how deeply fucked up this is: the world's forefront information highway and "marvel of technology" has been raped by capitalist soydevs so much that it is hundreds of thousands times less efficient than it should be, AND it wouldn't even require much effort to make it work well -- in fact it is much easier to make it work well. Imagine your car consuming 100000 litres of gasoline instead of 1 or your house leaking 99999 litres of water for any 1 litre of water you use, plus you paying extra money for it to be so. This is the absolute state of dystopian capitalist society. ~drummyfish }
________________________________________________________________________ | | | | | [X]| | ~!ENLARGE PENIS WITH SNAKE OIL!~ | | CSS | | Video AD | |__________________________________| | | | CONSOOOOOOOOOOOOO | | U.S. PRESIDENT ASSASINATED | BUG | | OOOOOOOOOOOM BICH | | | | |______________________| | Article unavailable in your country. | LOL | [make account or suffer]| | [log in to enable mouse scrolling] | | | | ___________________________________| |___ Prove you're a | | | |_______| | human, click all | | | We masturbate over your privacy <3 | images of type 2 | | | | quasars. | | | Consent with spying? | [*] [*] [*] [*] | | | _____ ______ | [*] [*] [*] [*] | | | | YES | | OK | | _________________ | | | """"" """""" |_ | FUCK MATURE MOMS|| | |_______________________________________________| || IN 127.0.0.1 || | | || CHAT NOW !!!1! || | | Your browser is 2 seconds old, please update || || | | to newest version to view this site. ||8000 NEW MESSAGES|| | | || hi dear, I NEED || | | PLEASE DISABLE ADBLOCK OR DIE || your cock || |_____|______________________________________________||_________________||
A typical website under capitalism, 2023. For potential far-future readers: this is NOT exaggeration, all websites LITERALLY look like this.
{ Ah this pseudoimage above made it to Encyclopedia Dramatica :D Thank you kind stranger <3 ~drummyfish }
Back in the day (90s and early 2000s) web used to be a place of freedom working more or less in a decentralized manner, on the principles of free speech, anarchism and, to the Yankee's dismay, even communism -- people used to run their own unique, non-commercial websites where they shared freely and openly, censorship was difficult to implement, unwelcome and therefore mostly non-existent and websites used to have a way better design, they were KISS, lightweight, safer, "open" (no paywalls, registration walls, country blocks, DRM, ...), MUCH faster and more robust as they were pure HTML documents, without scripts, "apps", jumpscare ads -- simply without bullshit. It was also the case that most websites were truly nice, useful and each one had a "soul" as they were usually made by passionate nerds who had a creative freedom and true desires to create a good website (and this still continued for a while after the invasion of businesses, i.e. commercial sites were still pretty bearable).
As the time marched on web used to stink more and more of shit, as is the fate of everything touched by the capitalist hand -- the advent of so called web 2.0 brought about a lot of complexity, websites started to incorporate and push client-side scripts (JavaScript, Flash, Java applets, ...) which led to many negative things such as incompatibility with browsers (kickstarting browser consumerism and update culture), performance loss and security vulnerabilities (web pages now became programs rather than mere documents) and more complexity in web browsers, which leads to immense bloat and browser monopolies (higher effort is needed to develop a browser, making it a privilege of those who can afford it, and those can subsequently dictate de-facto standards that further strengthen their monopolies). Another disaster came with social networks in mid 2000s, most notably Facebook but also YouTube, Twitter and others, which centralized the web and rid people of control. Out of comfort people stopped creating and hosting own websites and rather created a page on Facebook. This gave the power to corporations and allowed mass-surveillance, mass-censorship and propaganda brainwashing. As the web became more and more popular, corporations and governments started to take more control over it, creating technologies and laws to make it less free. By 2020, the good old web is but a memory and a hobby of a few boomers, everything is controlled by corporations, infected with billions of unbearable ads, DRM, malware (trackers, crypto miners, ...), there exist no good web browsers, web pages now REQUIRE JavaScript even if it's not needed in principle due to which they are painfully slow and buggy, there are restrictive laws and censorship and de-facto laws (site policies) put in place by corporations controlling the web. Official web standards, libraries and frameweworks got into such an unbelievably bloated, complicated, corrupted and degenerated state (look up e.g. Shadow DOM) that one cannot but stare in astonishment about the stupidity.
Mainstream web is quite literally unusable nowadays. { 2023 update: whole web is now behind cuckflare plus [secure HTTPS safety privacy antipedophile science encrypted privacy antiterrorist democratic safety privacy security expert anntiracist sandboxed protection](https.md) and therefore literally can't be used. Also Google has been absolutely destroyed by the LLM AIs now. ~drummyfish } What people searched for on the web they now search on a handful of platforms like Facebook and YouTube (often not even using a web browser but rather a mobile "app"); if you try to "google" something, what you get is just a list of unusable sites written by AIs that load for several minutes (unless you have the latest 1024 TB RAM beast) and won't let you read beyond the first paragraph without registration. These sites are uplifted by SEO for pure commercial reasons, they contain no useful information, just ads. Useful sites are buried under several millions of unusable results or downright censored for political reasons (e.g. using some forbidden word). Thankfully you can still try to browse the smol web with search engines such as wiby, but still that only gives a glimpse of what the good old web used to be.
{ More of web 2023 experience: if you want to Google something as simple as "HTML ampersand", just to get the HTML entity 5 character code, you basically get referred to a site that's 200 MB big, loads for about 1 minute (after you pass 10 checks for not being a robot), has 50 sections and subsections like "Who This Tutorial on Copypasting 5 Character is for", "What You Will Learn in This Tutorial", "Time Required for Reading This Tutorial" (which without these sections would be like 3 seconds), "Introduction: History of HTML" (starting with Stone Age) etc. There are of course about 7 video ads between each section and the next. Then finally there is the & code you can copy paste, buried in level 12 subsection ("HTML Code" -> "History of Programming Since Napoleon Bonaparte" -> "How Ada Lovelace Invented Computer Science" -> "How Tim Berners-Lee Stole The Idea For Web from His Wife" -> "Why Women Only Crews For Next Space Mission are a Good Idea" -> "How This All Finally Gets Us to HTML Amp Entity" -> ...). Then of course there follow about 600 more sections like "Methodology Used to Create This Copypasting Tutorial" etcetc. until "Conclusion: What We Have Learned about the HTML Amp Entity and History of Feminism"; but at least you don't have to scroll through that; anyway at this point you are already suicidal and don't even want to write your HTML anymore. ~drummyfish }
{ Another fun story: I just tried to compile badwolf completely from scratch (along with all dependencies) via pkgsrc on NetBSD on my Thinkpad t440p, which is an older laptop but still reasonably powerful, runs OpenArena smoothly. Badwolf is intself a minimalist browser with one downside: it depends on Webkit, as that's the only thing that allows access to "modern" web. So guess how long it took me to compile practically the most minimal browser to access today's web? I don't fucking know because I let it run overnight and halted it after 16+ hours not to go bankrupt over electricity bill. Absolute state of open soars. ~drummyfish }
WHY does every fucking SINGLE ONE, EVERY SINGLE WEBSITE ON EARTH have to have ads on it now? EVERY.SINGLE.WEBSITE.HAS.ADS. Everyone single FUCKING WEBSITE HAS ADS -- why? No, you fucking don't need money to run a website, stop giving this moronic argument. Don't you have $0.00000001 to pay for a domain and raspberri pi? Stop that fucking shit. Back then website didn't have ads and existed you idiot. Make a website without ads else spare us this shit and take it down.
As with most groundbreaking inventions the web didn't appear out of nowhere, as may seem in retrospect -- the ideas it employed were tried in times prior, for example the NABU network did something similar even 10 years before the web; likewise Usenet, the BBS networks and so on. Nevertheless it wouldn't be until the end of 1980s that all the right ingredients came together in the right mix, under ideal circumstances and with a bit of luck to get really popular.
World Wide Web was invented by an English computer scientist Tim Berners-Lee. In 1980 he employed hyperlinks in a notebook program called ENQUIRE and he saw the idea was good. On March 12 1989 he was working at CERN where he proposed a system called "web" that would use hypertext to link documents (the term hypertext was already around). He also considered the name Mesh but settled on World Wide Web eventually. He started to implement the system with a few other people. At the end of 1990 they already had implemented the HTTP protocol for client-server communication, the HTML, language for writing websites, the first web server and the first web browser called WorldWideWeb. They set up the first website http://info.cern.ch that contained information about the project (still accessible as of writing this).
In 1993 CERN made the web public domain, free for anyone without any licensing requirements. The main reason was to gain advantage over competing systems such as Gopher that were proprietary. By 1994 there were over 500 web servers around the world. WWW Consortium (W3M) was established to maintain standards for the web. A number of new browsers were written such as the text-only Lynx, but the proprietary Netscape Navigator would go to become the most popular one until Micro$oft's Internet Explorer (see browser wars). In 1997 Google search engine appeared, as well as CSS. There was a economic bubble connected to the explosion of the Web called the dot-comm boom.
Interestingly between 2000 and 2010 a mobile alternative to the web, called WAP, briefly came to the scene. Back then mobile phones were significantly weaker than PCs so the whole protocol was simplified, e.g. it had a special markup language called WML instead of HTML. But as the phones got more powerful they simply started to support normal web and WAP had to say goodbye.
Around 2005, when YouTube, Twitter, Facebook and other shit websites (or shall we say "webshites"?) started to appear and stole the mainstream popularity, so called Web 2.0 began to form. This was a shift (or shall we say "shit"?) in the web's paradigm towards more ugliness and hostility such as more JavaScript, bloat, interactivity, websites as programs, Flash, social networks etc. This would be the beginning of the web's downfall.
It's all pretty well known, but in case you're dumb...
Users browse the Internet using web browsers, programs made specifically for this purpose. Pages on the Internet are addressed by their URL, a kind of textual address such as http://www.mysite.org/somefile.html. This address is entered into the web browser, the browser retrieves it and displays it.
A webpage can contain text, pictures, graphics and nowadays even other media like video, audio and even programs that run in the browser. Most importantly webpages are hypertext, i.e. they may contain clickable references to other pages -- clicking a link immediately opens the linked page.
The page itself is written in HTML language (not really a programming, more like a file format), a relatively simple language that allows specifying the structure of the text (headings, paragraphs, lists, ...), inserting links, images etc. In newer browsers there are additionally two more important languages that are used with websites (they can be embedded into the HTML file or come in separate files): CSS which allows specifying the look of the page (e.g. text and font color, background images, position of individual elements etc.) and JavaScript which can be used to embed scripts (small programs) into webpages which will run on the user's computer (in the browser). These languages combined make it possible to make websites do almost anything, even display advanced 3D graphics, play movies etc. However, it's all huge bloat, it's pretty slow and also dangerous, it was better when webpages used to be HTML only.
The webpages are stored on web servers, i.e. computers specialized on listening for requests and sending back requested webpages. If someone wants to create a website, he needs a server to host it on, so called hosting. This can be done by setting up one's own server -- so called self hosting -- but nowadays it's more comfortable to buy a hosting service from some company, e.g. a VPS. For running a website you'll also want to buy a web domain (like mydomain.com), i.e. the base part of the textual address of your site (there exist free hosting sites that even come with free domains if you're not picky, plus alternative DNS systems such as OpenNic, just search...). When a user enters a URL of a page into the browser, the following happens (it's kind of simplified, there are caches etc.):
www.mysite.org) is converted into an IP address of the server the site is hosted on. This is done by asking a DNS server -- these are special servers that hold the database mapping domain names to IP addresses (when you buy a domain, you can edit its record in this database to make it point to whatever address you want).
http:// or https:// in front of the domain name) -- this protocol is a language via which web servers and clients talk (besides websites it can communicate additional data like passwords entered on the site, cookies etc.). (If the encrypted HTTPS protocol is used, encryption is performed with asymmetric cryptography using the server's public key whose digital signature additionally needs to be checked with some certificate authority.) This request is delivered to the server by the mechanisms and lower network layers of the Internet, typically TCP/IP.
Cookies, small files that sites can store in the user's browser, are used on the web to implement stateful behavior (e.g. remembering if the user is signed in on a forum). However cookies can also be abused for tracking users, so they can be turned off.
Other programming languages such as PHP can also be used on the web, but they are used for server-side programming, i.e. they don't run in the web browser but on the server and somehow generate and modify the sites for each request specifically. This makes it possible to create dynamic pages such as search engines or social networks.
A great deal of information on the Internet is sadly presented via web pages in favor of normies and disfavor of hackers who would indeed prefer to just download the data without having to do clickity click on seizure inducing pictures while dodging jumpscare porn ads. As hackers we aim to write scripts to rape the page and force it to give out its content without us having to do any dick sucking. With this we acquire the power to automatically archive data, hoard it, analyze it, do some netstalking, discover hidden gems, make our own search engines, create lulz such as spambots etc. For doing just that consider the following tools:
-dump option. Not only do they handle all the crap like parsing faulty HTML and handling shitty encryption bullshit, they also nicely render the page as plain text (again allowing further use of standard Unix tools), allow easily filling out forms and all this kind of stuff.
Zero (0) is a number signifying the absence of the thing we count. It's the mathematical way of saying "nothing". Among integers it precedes 1 and follows -1.
Some properties of and facts about the number zero follow:
NEZ, not equals zero) which can save memory and also be faster. So as a programmer you may optimize your program by trying to use zeros if possible.
It's common knowledge that dividing by zero is not defined (although zero itself can be divided), it is a forbidden operation mainly because it breaks equations (allowing dividing by zero would also allow us to make basically any equation hold, even those that normally don't). In programming dividing by zero typically causes an error, crash of a program or an exception. In some programming languages floating point division by zero results in infinity or NaN. When operating with limits, we can handle divisions by zero in a special way (find out what value an expression approaches if we get infinitely close to dividing by 0).