zarzavat

You may be causing a lot of cache misses. You have to use the caching efficiently otherwise you can burn up any plan in any amount of time.

Not on Mac OS, opening more than one instance is undefined behaviour. It may work, but it may also corrupt your data.

"AI at scale" is just a euphemism for slop. Current gen AI can augment human engineers but not outright replace them.

We can tell OP is using local or unencrypted DNS because they got DNS-redirected to a message.

If you have DoH configured at either OS or browser level then you will not see a message: the site will either work, or it will error out if the IP is blocked.

If you are using an alternative DNS provider over unencrypted DNS then either outcome is possible.

It may be nostalgia but I feel like we reached peak humanness with GPT-4o and since then it's been getting more and more alien. Particularly Fable.

Unfortunately it doesn't solve the problem because malicious code can still end up compiled into the user's program which they will promptly execute, possibly in production...

Supply chain attacks are not a problem that can be solved by a single silver bullet, however the biggest benefit comes from a combination of minimum release age + fresh 2FA required for every publish + automated scanning. This makes it considerably more difficult to pull off a supply chain attack and should be the baseline security for all package managers.

So instead of using JS to sort the table directly, now you make a JS fetch() request to sort the table?!

It does make sense in one situation, if the table is a large server-side paginated one and the sorting is really an ORDER BY clause. But for a basic table that fits entirely on the client, it doesn't make sense at all. There are tiny JS libraries that will make <table>s sortable when you add a particular class name.

This statement is a little too strong. It's a mistake to care about the equality of floating point numbers after subjecting them to irrational operations. On the other hand, the entire internet runs on the fact that doubles exactly represent the integers up to 2^53.

> But math never decreed that sine and cosine have to take radian arguments!

If you don't use radians you have to add to add conversion factors everywhere to do calculus. Radians are the natural unit for sin/cos just as E is the natural base of the logarithm and exponential functions.

Doesn't Google v Oracle provide protection here? Copying APIs is fair use.

If it's patents that are the problem then presumably all these large semiconductor companies have defensive parent portfolios.

Is CUDA still a moat? Are we not at the point where frontier models can reimplement software stacks, given you throw enough tokens at the problem.

> I'd remove user-defined generics from Go, and all the overcomplicated shit related to them, including iterator functions.

Go advances one blub ragequit at a time.

Models already reason in latent space, but they have to keep encoding-decoding their "thoughts" from/to human interpretable tokens, and notably those tokens are sampled from a distribution. The model cannot output a vector and have that same vector fed back in at the next step, it only sees what token the sampler collapsed its vector into.

It's as if the only way you could think was by writing down a word, erasing all the thoughts from your head, then reading the word you just wrote down and deciding on the next word, etc.

Reasoning purely in latent space means that the model would still produce an output equivalent to tokens but unconstrained e.g. the output could be raw and opaque vectors. A significant downside is that you lose the ability to inspect the reasoning trace. It would also make the reasoning trace potentially larger which has operational issues.

There's an inverse relationship between exposure to the effects of climate change and CO2 emitted per capita. The people who will need live preserving artificial cooling the most are exactly the people contributing the least to climate change.

In any case, the effects of extreme heat on the body are the easiest part of climate change to mitigate with current technology. The hard part is the famine.

LLMs don't have enough context to say No. What might be a very stupid idea in one context may be a fantastic idea in another context. It would be annoying if LLMs refused to complete tasks until you gave them enough context to understand why you are giving them such a task. It's going to take a while before LLM context capacities grow enough to rival a human's.

I do agree that it's a problem but the root cause is the fundamental limitations of current gen LLMs, it's not an alignment problem.

The only reason that Google keep Firefox around is because they find it beneficial for antitrust reasons.

We should prepare for a future without Firefox, because one day it won't be there anymore.

AFAIK they are using the built-in support which Google still maintains even if they don't expose it.

My point is that when MV3 was announced there was an assumption that maintaining a Chromium fork to continue supporting MV2 would be too much work and too expensive. But now with LLMs that's no longer a safe assumption. The non-Chrome chromium based browsers can fork chromium and add back MV2. No need for any expiration date.

I don't know why with LLMs we can't just add MV2/blocking web request support to Chromium in a fork.

The argument against was always that it's "too hard to keep a fork in sync". Now it's easier.

You are expecting consistent QoS from a randomly sampled mathematical function.

If you have exponentially increasing use of your harness, then it's true that every day you capture exponentially more data, but it's also true that every day exponentially more data will slip through the cracks of your would-be monopoly and that data arrives at your competitors via various channels (competitor harnesses, subsidized reselling, etc)

The very exponential that you are relying on to give you runaway improvement is also giving exponentially increasing data to your competitors. All else being equal your competitors stay a step behind but you never develop a monopoly either. That's the best case for Anthropic/OpenAI. In reality, training data is just one variable, exponentials don't last forever, and your competitors will get better at capturing a bigger slice of training data.

That makes them at best temporary middlemen.

It only justifies their long term valuations if they can leverage that temporary monopoly for technological superiority (they can't) or lasting market share (they can't).

Chinese models prove there's no technical advantage, and the software side is heavily commoditized so there's not much advantages to market share either.

My calculus is very simple these days:

If I care about performance, use Rust.

If I care about iteration speed, use TypeScript.

If I want a script or numerical code, use Python.

LLMs are better with Rust because the more expressive type system provides stronger guardrails especially when writing multithreaded code. Go is almost the worst conceivable design of a programming language for LLMs: powerful but weak guardrails. Only C and C++ would be worse.

LLMs don't struggle with the low-level lifetimes like humans do. They struggle with the high-level view because of limited context windows. That's why you want a powerful type system to enforce those global constraints. Go ain't it.

I love the word "including" there. Yes it will be used for people suspected of minor crimes but it also includes people accused serious crimes as well!

LLMs, both in writing and mathematics seem to only be capable of coming up with texts that are inside the distribution of the training data.

With writing it's just more obvious. LLMs don't write with personality. They don't create new and exciting worlds on their own. Everything they output feels derivative.

In mathematics you see the same effect. They are very good at finding results that humans missed, taking advantage of their broad knowledge and tireless work ethic.

But just as they have been unable to create new literary worlds, they also have so far been unable to create new mathematics.

I believe this lack of creativity is intrinsic to how these models are architected and trained. We want models that produce these in-distribution outputs because those types of models are more economically valuable. Nobody wants a coding agent with spontaneity, we want models that predictably and obediently solve problems - and that's what we got.

This result is some evidence that AI will not solve RH soon. If there were any easy solution hiding in plain sight then it probably would have found it.

Solving RH likely requires AI that is substantially more creative. But we haven't even solved the creativity problem for writing let alone mathematics. I believe that transformers are a trillion dollar local optimum that we will find it very hard to escape.

Let's wait for the models to produce a good novel first.

A distinction is that Alzheimer's is in an uncommon category of mystery diseases.

If a study found people who swim regularly are are less likely to get heart disease, that wouldn't be very surprising because know a lot about why people get heart disease. Therefore it would be valid to insist on more rigour for accepting (swimming => less heart disease) because the only use of that information is for health advice.

However even weak statistical correlations can be a valid lead for further research into Alzheimer's disease if they suggest where to look. You don't need to prove that signposts are correct in order to use them.

I don't use yolo mode but if you allow your agents to both write code and run/test it, then it's basically equivalent to running in yolo mode anyway.

The other day I caught Claude including a rm -rf equivalent (fs.rmdir({ recursive: true, force: true })) in my code, to clean up temporary directories. It was fine, but that kind of code is only one misconfigured environment variable away from blasting away your $HOME.

Canvas is a last resort if you absolutely cannot build the thing any other way.

When you use canvas you're giving up on not just accessibility but also optimizations that the browser does for you transparently when you use the native render tree. There's no guarantee that your app will be faster in canvas, it could easily be slower. Do you really think you can beat the browser's C++ by writing code in a language that doesn't even have a native integer type? Perhaps you can, but your base assumption should be that you can't.

The USG getting involved might actually harm US AI efforts. It's not just about money. Who would want to use Claude or ChatGPT if it were run by the US government? Yet these products are essential for gathering training data.