The image is a cropped xkcd with the text replaced but the same joke.

I was a bit apprehensive because rust has like a gazillion different function types but here it seems to work like just any other language with a HM type system.

The fn(T)->R syntax works for functions without associated data, it discards details of the implementation and works like function pointers in C. This allows them to be copy and 'static.

The other function types can have data with them and have more type information at compile time which allows them to be inlined.
These functions each have their own unwritable type that implements the function traits (Fn(T)->R, FnMut(T)->R and FnOnce(T)->R) depending on their enclosed data.

I hope I remembered everything right from this video by Jon Gjengset.

Jetbrains products also have a fallback license after a year, so you retain perpetual acces to an old version* and I don’t think there is much change in the space of git UIs.

* iirc the version that you had one year before your payment lapsed, it applies to discounted versions as well

Prolog is not suitable for any problem domain, although this is more readily apparent for some domains than others.

For real, for real.

Short answer:
It gave us compiler explorer, now that it has served its purpose we should stop doing it.

Long answer:

Why does hft even exist?

Hft can exist because most stock markets react to requests as fast as possible and have no noticable fees for certain use cases. This means algorithms that do simple trades like if goggle goes up, buy other tech companies or buy any stock that goes up in europe on the NY market can make small profits if they are faster than everyone else.

Does it have any value?

There is one exchange that imposes a delay on every request, effectively inhibiting hft, and its opening actually improved market conditions on all exchanges. This implies it has negative value.
They also spend millions on hardware, tools and developers to skim small sums of many transaction on the stock market. They are effectively a (very inefficient) tax on the stock market that goes to improving C++ compilers and funding hardware startups.

A yes, the two genders of binary file formats: renamed sqlite file and renamed zip folder.

The other atomic clocks that are averaged to give us our ground truth for time.

… or one second back, that’s the problem.

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.

The new version seems to fix that since your comment was written, but it will stil panics if less than 2 samples are provided, unless the crate it wraps panics at an earlier point.

let peak = buf
            .iter()
            .copied()
            .enumerate()
            .take(self.sample_count / 2)
            .max_by_key(|(_, s)| (s.abs() * 1000.0) as u32)
            .expect("to have at least 1 sample");

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 _

While that works for “news agencies” it’s a free money glitch when used in a customer support role for the consumer.

Edit: clarification

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.

I looked at the diff, it’s around 100 lines of new code and a few hundred lines of comments and tests.
I couldn’t have written it, but there are many smarter people that fixed it after they learned of the problem.

What also made it easier to fix is that they (sensibly) chose to error on certain strings that can’t be escaped safely.

Keyword reserving is always exciting.
In this case it’s gen, which allows iterators build on the state machines currently powering async.

Here is a contrived use case from me.
It’s not as groundbreaking as async but it’s a convenience. And hey, you could write futures without the async/await keywords, but it’s easier with them

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.