AlotOfReading

You might not be aware, but Baumgartner has a generally negative reputation in the conservator community. From what I understand as a non-expert, he's overly aggressive with his swabbing/varnishing and he's taken power tools directly to an artwork numerous times. The former isn't obvious to me either.

If it's not clear, my post was about school curricula.

If you spend any amount of time listening to people complain about what is or isn't taught, you'll quickly discover that most things they hate aren't taught and the things they wish were taught are, at least in some form. Much of the rest is based on either outdated or misunderstood knowledge/beliefs.

They very much understood their situation. That was the means of control. Their incomes were directly defined by agricultural productivity, and their expenses largely controlled by the shogun. Daimyo couldn't meaningfully communicate with each other, easily intermarry, or form alliances. They were forced to maintain huge retinues and lavish estates, and the shogun could bankrupt them or kill their family at any point.

The shogunate needed to do some balancing along the way (including the introduction of metallic currency), but the government had enough levers to keep the samurai in line, right up until they couldn't.

These are remarkably close to the raw cost of materials and tooling. The Sagrada Familia model is a 12k piece set for $800, ~$0.07/piece. Phantasy has an unlicensed Opera set (85019) [0] with 3.5k pieces for $190, $0.05/piece. That's straight up cheap. They're not limiting production to control prices. High quality injection molding (in multiple colors no less!) is hard. 2 cents over 12k pieces does add up to a nice bit of change for Lego though.

[0] https://pantasy.com/products/pantasy-the-opera-85019

Pantasy, Cobi, Funwhole, megabloks, etc. There's tons of alt bricks at nearly any reasonable price point. But you're still not going to find these sorts of multi-thousand piece sets for <$100 because it takes at least a few cents to produce a dimensionally accurate, quality controlled bit of plastic.

Because the other responses are incredulously focused at why someone would ask such a dumb question, the answer is that oceans affect everyone's lives.

Ocean currents and temperatures are major factors in storms, economic activity like trade, and ecosystems across the country. Monitoring them costs virtually nothing, and the benefits are huge.

LLVM does speculative devirtualization as well these days, though it's not as aggressive as Hotspot. High-performance native code tries to avoid deep dynamic hierarchies anyway, so it's mitigated by cultural practices.

GCs are definitely a strong point for Java, but most high-performance code can be rewritten to avoid pummeling memory management. This used to be common for Java in financial applications, not sure if it still is.

C++ has evolved its own compacting GCs like oilpan [0] for applications where high performance is inherently tied to allocation. Oilpan runs into pointer issues and isn't remotely comparable to G1GC or ZGC, but I think the speed of V8 speaks for itself. Rust allows you to drop in non free-list based allocators and GCs (e.g. Bumpalo), but they're relatively immature.

    That may be because the information on that page seems to be up to date to 2011-2. Java is now on version 26, BTW.

The last time I dove into JVM internals was around the same time. I figured that someone who's worked with it more recently might have better examples than what's easily searchable.

[0] https://chromium.googlesource.com/v8/v8/+/main/include/cppgc...

    I don't know what it is that Rust demonstrates given that few large scale projects have chosen it, but I've seen nothing to indicate that it doesn't suffer from the same performance issues as C++ compared to Java. 

The point of bringing up Rust is that it also gives the compiler much more information to optimize on than C++, but actual performance is comparable or slightly worse in most benchmarks because the quality of C++ codegen is so high. Some of those Rust advantages are exactly the same things that have been touted as major advantages for Java over C++, like escape analysis and lifetimes.

    Of course, in principle it's always possible to match and perhaps even exceed Java's performance in a low-level language, but in practice it becomes ever more difficult as the program grows (and the cost remains with maintenance forever).

Sure, which is why I asked for real examples of whatever you consider a "large scale" program. I wasn't able to find anything via search before I replied, and the wiki page on Java performance [0] is repeating what I understood.

[0] https://en.wikipedia.org/wiki/Java_performance

    In general, the tradeoff is between optimisations that help large programs vs optimisations that help small programs.

Do you have concrete examples of large scale Java programs that are significantly more performant than comparable programs in native languages like C++? My understanding was that this dynamic hadn't fundamentally changed much since the 2010s, when Java was able to occasionally edge out a win in 1-2 benchmarks and would lose handily in others. My experience is that large scale Java programs remain a bit of a bear even after significant optimization effort (e.g. Bazel).

There are of course plenty of optimizations the JVM does that aren't possible AOT, but that that doesn't imply an automatic win at large scales, as Rust demonstrates.

Another example is history. It's theoretically possible to become an academic historian through private study and there are certainly no legal barriers to it, yet amateurs almost never make the transition except through higher education.

Now if only GM's executives could stop snatching defeat from the jaws of victory.

A former employer once had Christmas layoffs. Their way to help was preemptively giving these scammers a list of everyone's contact info as "relocation assistance".

That's what the Arm SystemReady certification is for. Blame manufacturers for ignoring it. Let's be honest, fixing device trees is usually lot easier than patching an ACPI table. Though, one manufacturer I know ships a DT with nearly 500k lines of if-def'd nodes.

There's a lot of companies trying to support datacenter systems like GH and Rubin that don't have dev hardware remotely resembling it. M-series isn't a good option, speaking from the personal experience of currently using one for this exact purpose.

What an awful university press release. "Randomness amplification" is just the old concept of a randomness extractor with quantum tacked on. It's a neat demo at best.

Considering cancelling mine because they've introduced ads to it in the form of undismissable "purchase the product being discussed here" affiliate popups.

Compilers are orders of magnitude more reliable than LLMs. There's a reason the saying is "it's not a compiler error".

I have a standing challenge to my co-workers that valid compiler errors will be rewarded like a birthday party, with the baked goods, alcohol, or sweets of their choice. It's only been redeemed once, and I've found less than a dozen unreported compiler bugs myself.

I don't know if you work in embedded, but I do and I've always understood zero alloc as "no dynamic allocation".

Most companies buying anything from WolfSSL will already be using a script or toolchain flags to validate stack usage. And if they don't, even embedded toolchains generally support canaries these days.

If we imagine 1 tweet = 1 transaction, that's only 6k tps. 6k tps is completely achievable, dare I say even pedestrian for an optimized database. And most systems are operating far below the scale of Twitter/X.

Bit of context to this, it was demonstrated that it was a hypothetical possibility, but the issue couldn't be demonstrated in lab conditions. Stuck floormats, pedals, and confused drivers remain the only actual explanations for the real events behind the lawsuits.

LLM comment? The link is about randoseru, which are not satchels and predate the existence of both discord and powered flight.

I'm not sure whether they're biologically unique (as fingerprints are not), but the way standard scanners work has both false positive matches and false negatives. NIST maintains benchmarks for biometric errors, which are usually in the tenths of a percent range.

I guess you should hope none of your hundreds of thousands of iris neighbors are placed on the list?

Most software picks 1-2 distros (usually LTS Ubuntu and/or Fedora) to support in the default configuration.

CFD might reasonably be considered part of CAD and something like ansys costs about as much as catia. Still only doubles it though.

You can buy home repair insurance if you want to transform unexpected repair expenses into predictable monthly payments. It's a bad idea for exactly the same reasons renting is worse:

Someone else has to approve repairs and contract the labor.

My experience with corporate landlords is that they're incentivized to maximize income, which is emphatically not the same as keeping you renting the place as long as possible. Realpage for example optimizes for higher income at the cost of turnover and lower occupancy.

IBM still sells extremely POWERful systems, but they don't seem particularly interested in expanding the market.

I once had a conversation with a director of that division about why it wasn't on the market. It basically came down to the existing customers being willing to pay such exorbitant amounts for each system after all the support contracts that "normal" markups like Nvidia and Intel enjoy were too paltry in comparison.

Sure, but custom integrations seem unlikely to explain the majority of Uber's technical headcount. Let's say they average a dedicated engineer for each of their 1000 largest markets/locations. Let's assume another 200 across the countless smaller markets. Let's assume 50% overhead atop this for things like infra, tools, and management. These all seem like exceedingly generous estimates to me.

They actually had 5,000 engineers in the tokenmaxxing blog post. That's a lot of engineers for the rest of Uber's business activities.

     Don't get me started with bike helmets

Bike helmets mitigate one of the most serious and common forms of injury while riding bikes. You can fall or be hit by a car/tree branch anywhere. They don't prevent you from doing anything you would otherwise do.

I'm someone who advocates for rolling back helmet laws because they decrease ridership, but helmets are a fantastic example of reasonable PPE, not overactive safetyism.

Let's imagine you're drilling oil instead. You have to spend billions of dollars over years finding and developing a new oilfield to make any profit back. And once you have it, you have to continuously spend enormous amounts of money to keep producing it, which means your effective price floor is higher than the current stable price.

Now it's 2021 and someone gets a tanker stuck in the Suez, sending the price of oil sky-high. How long does the ship have to be stuck before you spend those billions of dollars on a bet that it'll recoup before someone gets the ship out?