What is the methodology called where you:

Plan to go to orbit, blow up seconds into the flight, and declare it a success.

Plan to refuel in orbit, make it minutes before the rocket brakes. Fire the FTS, it fails, the rocket blows up a minute later und declare it a successful test of the FTS.

Argue to NASA that you are not the limiting factor to the moon mission planed for the end of the year, despite delivering none of the milestones.

FTS = flight termination system

I think Dylan Beattie once said: If you don’t have a plan, how can you choose not to follow it?

Websites have grown beyond mere scripting.
Rust is about more than just nicer pointers, it has a very expressive type system that enables correctness rarely seen outside FP.

Instead of

if let Some(a_) = a{
    ()
} else if let Some(b_)=b{
    ()
} else {
    dostuff 
}

you could just use

if a.isNone()&&b.isNone(){
    dostuff
}

Also if you don’t use the value in a match just use _

Sleep sort is kind of like count sort but with added overhead. Both have a complexity of O(n+m) with n being the length and m the value of the max element.

The optimum of O(n * log n) is based on the assumption that the only information about the values is obtained by comparison. If you operate on integer keys I would recommend radix sort. It has a complexity of O(n * w) where w is the length (read logarithm) of the key.

I can’t find the name/source at the moment, but if you enumerate all turing machines and run them concurrently* you will find the optimal algorithm for your problem in O(1) and executed that.
To my knowledge the algorithm is so inefficient on small input that it takes hours to solve integer addition.

* You run the first turing machine one step, than the first two one additional step, that the first tree… This allows you to run an unlimited amount of TMs an unlimited amount of steps.

Look at me, I have a friend at bell labs.
We had to use vacuum tubes, and we liked it.

The main difference is that WASM is an agnostic bytecode without a gc while the jvm is opinionated in a java way. It has a gc, focus on dynamic dispatch and it has knowledge of concepts like exceptions, classes and visibility.

All this leaking of abstractions means languages like java and kotlin are well suited, scala has hit problems and c couldn’t be compiled to java bytecode.

It all comes from OP.

Actual assembly in mainstream use:
x86
arm
risc v

mainstream byte code:
jvm
.net (I think)
wasm

fake assembly people may write:
llvm
wasm

wat (web assembly text) is actually written is S-expressions, like lisp but without code as data.

Edit: formatting

Thanks, I missed it.

You can always increase the precision of a computation, analog signals are limited by quantum physics.

Show me the regex for the language L = a^n b^n n in N

Neat idea but it needs the ape loader to be installed.

In my IDE there us even a button for accepting the compilers recommend fix. This is only possible because the error messages and recommendations are that good.

What’s the problem with -0?
It conceptually makes sense for to negativ values to close to 0 to be represented as -0.
In practice I have never seen a problem with -0.

On NaN: While its use cases can nowadays be replaced with language constructs like result types, it was created before exceptions or sum types. The way it propagates kind of mirrors Haskells monadic Maybe.
We should be demanding more and better wrapper types from our language/standard library designers.

Just build submarines, smh my head.

https://xkcd.com/1586/

You can’t random-access an iterator and use it again later.

If your specific use case really needs random access to a list while lazy computing the elements just wrap them in Lazy and put them in a vector.

Can Rust compute the value of calling a function an infinite number of times?

The return type of an infinitely recursive function / infinite loops is ⊥, a type that by definition has no values. (Known in rust as !)

Imagine using a linked list as your default sequential container.
Rust iterators are lazy btw.