I quite enjoy Nix flakes for this. Only certain languages have good support though (C, Rust, Haskell, OCaml, ...).
It's easier to write that much if you are just making stuff up...
I don't have 2 mil, how do I get out of this? File for bankruptcy?
Linux is already better than Windows, the latest versions are a mess, and is likely going to get worse.
A package is reproducible if you use the same inputs, run the build, and get the same outputs.
The issue is that the build can produce different outputs given the same inputs. So you need to modify the build or patch the outputs. This is something that is being worked on by most distributions: https://reproducible-builds.org/who/projects/
NixOS is not special in that regard nor are all NixOS packages reproducible.
Nope, nix doesn't ensure or require that the builds are deterministic. It's not any better in that regard than other package managers.
It's not really fully reproducible either.
Remove the wall plug, straighten the paper clip and insert it into the cable in between the wires, reinstall the wall plug.
All is not a "for you" feed, it contains posts from the whole fediverse. You are supposed to add the filter yourself. Find the communities you are interested in, subscribe and then browse that.
I like to think of the universe as a machine. It might as well be machines all the way down.
However, I absolutely reject the idea that we aren't an emergent part of this universe.
You don't even need soil, you can just put them on the ground and cover them with hay, and they grow just fine.
Yes, I meant a bouillon or stock cube, sorry for the typo. Or you can use stock or a broth instead of water.
Stock is also pretty easy to make. You can buy a whole chicken and then throw the leftover carcass, skins, bones, with onions, carrots, celery and some herbs into a pot and simmer it for 2 hours.
You can also saute an onion before adding the rice and water, and add a bullion cube, to improve the flavor.
As you already figured out the types are sets with a certain number of elements.
Two types are isomorphic if you can write a function that converts all elements of the first one into the elements of the second one and a function which does the reverse. You can then use this as the equality.
The types with the same number of elements are isomorphic, i.e True | False = Left | Right. For example, you can write a function that converts True to Left, False to Right, and a function that does the reverse.
Therefore you essentially only need types 0, 1, 2, 3, ..., where type 0 has 0 elements, type 1 has 1 element, etc. and all others are isomorphic to one of these.
Let's use (*) for the product and (+) for the sum, and letters for generic types. Then you can essentially manipulate types as natural numbers (the same laws hold, associativity, commutativity, identity elements, distributivity).
For example:
2 = 1 + 1 can be interpreted as Bool = True | False
2 * 1 = 2 can be interpreted as (Bool, Unit) = Bool
2 * x = x + x can be interpreted as (Bool, x) = This of x | That of x
o(x) = x + 1 can be interpreted as Option x = Some of x | None
l(x) = o(x * l(x)) = x * l(x) + 1 can be interpreted as List x = Option (x, List x)
l(x) = x * l(x) + 1 = x * (x * l(x) + 1) + 1 = x * x * l(x) + x + 1 = x * x * (l(x) + 1) + x + 1 = x * x * l(x) + x * x + x + 1 so a list is either empty, has 1 element or 2 elements, ... (if you keep substituting)
For the expression problem, read this paper: doi:10.1007/BFb0019443
The sum and product types follow pretty much the same algebraic laws as natural numbers if you take isomorphism as equality.
Also class inheritance allows adding behaviour to existing classes, so it's essentially a solution to the expression problem.
The way you can think of it is that in OCaml everything is implicitly wrapped in an IO monad. In Haskell the IO monad is explicit, so if a function returns something in IO you know it can perform input and output, in OCaml there is no way to tell just from the types. That means that in Haskell the code naturally stratifies into a part that does input and output and a pure core. In OCaml you can do the same thing, however it needs to be a conscious design decision.
I dread buying new things that I don't know much about now. On the flip side that has saved me so much money :)
The implementations mostly don't matter. The only thing that you need to get right are the interfaces.
XKB config files work under sway without XWayland.