repsilat

Yes, the grandparent scored an own goal with their aside

>> The "free market" (which has been demonstrated to not be free at all)

The Berlin rental market suffers under strong government intervention, and would benefit from being much freer.

Yeah. It's worth looking at your own code and infrastructure as well. In my previous job there were dozens of opportunities to realise big savings by swapping out gzip for other compression schemes -- usually zstd, occasionally lz4 or bz2 or brotli. Huge assets took less hard drive space, took less time to download, and took less time to decompress. The differences were not small, and resulted in appreciable improvements both in infra cost and dev productivity.

Maybe that's the right approach, hard to say. No great harm making this kind of improvement if it isn't the globally best architectural direction.

> you have two options

There are many other ways to allocate capacity. For example, you could give preferential access to customers who sign long-term purchase commitments, or some other favourable terms. These other methods might correlate well with value to the seller and might be easier for buyers to pay.

Other methods could be "allocate to customers that you want to maintain a good relationship with." I suspect HBM is not allocated either with pure auctions or by lottery.

Faster is better than slower.

Postgres is amazing. When I use Sqlite I miss many of its upsides--better data migrations and better concurrency being two. But queries are not free, and sometimes are slower than I'd like even with the right indexes. And for OLAP-like queries like the one in TFA you might say "well, just don't use postgres for that," but wouldn't it be better if you could? If you could use one database instead of two, or use your favourite database in more places instead of reaching for a different tool?

> every few millennia

We'll feel awful silly having made any leap seconds if the robots kill us all in the next decade.

More seriously -- all of today's computers and probably all of today's software (not to mention many scientific and governmental institutions) will be gone in 500 years. Does it make sense to plan too far ahead?

I had an issue in a CI pipeline once where clocks on two different machines drifted out of sync, and it looked like an HTTP request went back in time (it had some validity from now until now plus some delta, and the second machine thought it arrived "before now"), validation failed, pipeline failed.

An unusual case, fragile design, but indicative of potential issues with more interesting timekeeping choices.

One way of thinking about ignoring leap seconds is that it's like letting the effective prime meridian drift east/west. And a "leap hour" is kind of like a timezone change. In fact, you could just not have a centralized/coordinated leap hour, and let individual jurisdictions change their own timezones as they wanted, if they wanted noon to be closer to the daily solar peak.

Occasionally in pure python "asymptotically reasonable, simple implementation, terrible memory locality" is the right pick for a data structure. You want to avoid an extra linear term, you don't care too much about the constant factor, and the cache doesn't really matter because the language is so slow that it's not really noticeable.

Not too common, but it happens.

I guess to expand on my earlier post, it's generally a good thing that these kinds of absurd allegations are counterproductive and generally not convincing, because if they were more readily believable they would be quite irresponsible. Real violence has occurred because of beliefs (and posts) like this.

This hyperbole does more to turn people away from Bluesky and other sites more than X to be honest. There are clearly lots of politically moderate, wholesome "politically inert," and international X users. The people who are vocal about having left seem more extreme and less tolerant to me.

Perhaps for related reasons, I've also recently heard Elon Musk being described as a "literal Nazi" a lot, and I'm sure that kind of wild rhetoric has a similar backfire effect with anyone who has any familiarity with him.

Yeah I guess a c++ programmer might say `std::array::operator[]` is a function (or method, whatever), just like `std::array::size` is. And that identifying the array with just one of those functions (or even the collection of all methods offered) is to miss the point -- not just contiguous indices, but contiguous storage. A red-black tree with added constraints is not an array.

TFA does allude to this. An "array indexing function" that just met the API could be implemented as an if-else chain, and would not be satisfactory.

I wonder if "the right solution" is a programming language that is fast, concise, trivially easy to run, and outputs some efficient binary format like protobuf.

Programming languages have comments and control flow, multiple popular implementations, and can have nice literals. Lack of Turing completeness is actually not a terribly useful feature if you trust the input (and you should probably just use protobufs or similar for untrusted inputs in that case.)

"Easier" is probably the right one-word generalization, but worth noting that there are quite different challenges. Stopping distance is substantially greater, so "dead halt" isn't as much of a panacea as it is in dense city environments. And you need to have good perception of things further away, especially in front of you, which affects the sensors you use.

There's an Amdahl-like effect, where "100x slower" means that anything nontrivial in pure python ends up being fat in your flamegraphs, even if your "heavy lifting" core algorithmic stuff uses some nice fast libraries.

For compute-heavy code "100x slower than C++" is a good rule of thumb in my experience in python 3.10.

Many simple scripts at my work that more or less just argparse and fire off an HTTP request spend half a minute importing random stuff because of false deps and uncommon codepaths. For some unit tests it's 45 seconds, substantially longer than the time taken to run the test logic.

In dev cycles most code is short-running.

For cloud jobs that can be true, but for single threaded dev-in-the-loop work you can't just buy a 100x faster processor than the one on their dev machine, and the latency is expensive workflow friction.

This might have been your experience, but mine has been very different. In my experience a typical python workload is 50% importing python libraries, 45% slow python wrapper logic and 5% fast native code. I spend a lot of time rewriting the python logic in C++, which makes it 100x faster, so the resulting performance approaches "10% fast native logic, 90% useless python imports".

Yeah, I think the "paradox" is usually a problem for pundits and academics and not practitioners. Lots of people have experience finding and correcting market inefficiencies, usually getting paid for it.

A system of n experts is no different to a single expert wrt the NFLT. The theorem is entirely indifferent to (ie "equally skeptical of") the idea.

Releasing an open source product that improves on alternatives doesn't sound like ”stealing” or ”adding no value" to me.

They're giving away something valuable, same as the people whose work they're building on top of.

I wonder about the global statistics of sorted data... Is the most common number of elements to sort zero? Certainly less than ten?

What about the median? Two elements to sort? One? Zero again?

It's the bank. One of the biggest US retail banks. Maybe other big ones don't, maybe I should change banks.

I have great credit and my bank charges me $3 every month to pay my rent. (They will send a cheque in the mail for free, but it wasn't reliable for me so I stopped doing that.) Third world stuff.

For this sort of change I think the best strategy is "two passes".

Auto-format those O(30k) files and get global approval. Then, separately, make your two-line semantic change and seek approval from local owners.

Maybe it was 6gu.nz (site broken) https://www.youtube.com/watch?v=afXzeCuUuhU. I wrote it about 5 years ago and probably mentioned it in a couple of comments here. It had draggable tables on the normal 2d grid, with references between them.

The "mango" lib [1] claims to be even faster for PNGs. Actively maintained but doesn't have as much buzz, I think the devs haven't advertised it as much on places like this.

Also, it has the funniest testimonials.

1: https://github.com/t0rakka/mango

Maybe it's an uncanny valley thing, but I hate the fake emotion and attitude in this demo. I'd much rather it tried harder to be bland. I want something smart but not warm, and I can't imagine being frustrated by "lack of drama".

This math is way off. _Guaranteed_ doubling in 4 years is a 19% per annum return. If the "not doubling" case is "break even" (generous) then the expected growth is under 10% per annum.