deleted by creator

deleted by creator

Just buy a new SSD to install Linux on. If you decide to switch back just plug the old one in.

I quite enjoy Nix flakes for this. Only certain languages have good support though (C, Rust, Haskell, OCaml, …).

I don’t have 2 mil, how do I get out of this? File for bankruptcy?

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.

deleted by creator

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 implementations mostly don’t matter. The only thing that you need to get right are the interfaces.

Well, most people installing Arch for the first time have no idea what a typical Linux install does under the hood. That makes it a worthwhile learning experience. The same commands you use during the setup you can later use to fix or change things. It basically forces you to become a somewhat proficient Linux user.

On a phone with spyware installed that wouldn’t do anything. There are probably ways to get rid of it, but how can you be sure?

Nope. Monads enable you to redefine how statements work.

Let’s say you have a program and use an Error[T] data type which can either be Ok {Value: T} or Error:

var a = new Ok {Value = 1};
var b = foo();
return new Ok {Value = (a + b)};

Each statement has the following form:

var a = expr;
rest

You first evaluate the “expr” part and bind/store the result in variable a, and evaluate the “rest” of the program.

You could represent the same thing using an anonymous function you evaluate right away:

(a => rest)(expr);

In a normal statement you just pass the result of “expr” to the function directly. The monad allows you to redefine that part.

You instead write:

bind((a => rest), expr);

Here “bind” redefines how the result of expr is passed to the anonymous function.

If you implement bind as:

B bind(Func[A, B] f, A result_expr) {
   return f(result_expr);
}

Then you get normal statements.

If you implement bind as:

Error[B] bind(Func[A, Error[B]] f, Error[A] result_expr) {
   switch (result_expr) {
       case Ok { Value: var a}:
           return f(a);
       case Error:
           return Error;
   }
}

You get statements with error handling.

So in an above example if the result of foo() is Error, the result of the statement is Error and the rest of the program is not evaluated. Otherwise, if the result of foo() is Ok {Value = 3}, you pass 3 to the rest of the program and you get a final result Ok {Value = 4}.

So the whole idea is that you hide the if Error part by redefining how the statements are interpreted.

You can probably replace it with ImageMagick.

Some people consider working on programming languages fun, so they create new ones.