DougBTX

For numerical work, there’s no reason to assume the computation is happening in the LLM. All frontier models could handily write a Python script to do linear regression then report the result, so the quality of the responses here depends entirely on the prompt + harness.

> we set up limits for a maximum of 256 process per UID, and regularly get folks asking "what does this 'cannot fork' message mean?"

The max limit on 64 bit systems is what, 4,194,303? So if you have over 16,000 users per VM this limit makes sense, otherwise it just seems user-hostile.

April last year

Yeah, we’re in a funny position. By all accounts it is fair use (at least in the US) to train models (and build search indexes, e.g. Google Books), but sharing the books dataset itself is absolutely forbidden (clear non-transformative copying).

Anyone that wants to train a model needs to procure and destroy their own physical copy of each book!

Oh, thanks, that’s interesting, I thought it covered that too!

> GPUs put the associativity of the sums in matrix multiplications in arbitrary order

That’s user-controlled too, not an inherent property of GPUs:

https://docs.pytorch.org/docs/2.12/generated/torch.use_deter...

The weights are code, the prompt is code, the output is code.

Is the meat code?

Zed is also released under GPL 3:

https://github.com/zed-industries/zed/blob/main/LICENSE-GPL

Here's the page for the notebooks-with-maps: https://www.moleskine.com/en-us/shop/limited-editions/the-lo...

> In this case it’s a relatively small dependency so it’s not the end of the world, but it’s the exact same principle.

An alternative world-view is: "A little copying is better than a little dependency," from https://go-proverbs.github.io

Does become subjective about what "small" and "little" are though.

The train/test split is one of the fundamental building blocks of current generation models, so they’re assuming familiarity with that.

At a high level, training takes in training data and produces model weights, and “test time” takes model weights and a prompt to produce output. Every end user has the same model weights, but different prompts. They’re saying that the constitution goes into the training data, while CLAUDE.md goes into the prompt.

I can’t tell if this is sarcasm or not! Radio buttons support keyboard navigation without JS.

> but how is the result "stored"

Like this: https://huggingface.co/docs/safetensors/index

Spicy:

> Use caution when using the manual door release; the window will not automatically lower when the door is opened and damage to the window or vehicle trim may occur.

Manually opening the rear doors is a destructive operation!

Yes, from the article:

> To support the cluster’s massive scale, we relied on a proprietary key-value store based on Google’s Spanner distributed database... We didn’t witness any bottlenecks with respect to the new storage system and it showed no signs of it not being able to support higher scales.

> Then you can roast the meat pieces in a closed glass vessel

It sounds like this is steamed meat, as opposed to roasted. Your cooking time seems to match a quick search for steamed chicken recipes: https://tiffycooks.com/20-minutes-chinese-steamed-chicken/

From https://usafacts.org/articles/is-flying-safer-than-driving/

> In 2022, the fatality rate for people traveling by air was .003 deaths per 100 million miles traveled. The death rate people in passenger cars and trucks on US highways was 0.57 per 100 million miles.

Planes travel about 10x-20x faster than cars, but that’s still 0.06 vs 0.57. Seems like quite a difference. Which numbers are you using?

> I want everything that passes through a function to be a copy unless I put in a symbol or keyword that it suppose to be passed by reference.

JavaScript doesn’t have references, it is clearer to only use “passed by reference” terminology when writing about code in a language which does have them, like C++ [0].

In JavaScript, if a mutable object is passed to a function, then the function can change the properties on the object, but it is always the same object. When an object is passed by reference, the function can replace the initial object with a completely different one, that isn’t possible in JS.

Better is to distinguish between immutable objects (ints, strings in JS) and mutable ones. A mutable object can be made immutable in JS using Object.freeze [1].

[0] https://en.wikipedia.org/wiki/Reference_(C%2B%2B)

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Perhaps it has to be that way, the motivation to build a mechanical computer is based on the belief that computation can be mechanised.

1999, $25 million investment: https://googlepress.blogspot.com/1999/06/google-receives-25-...

2000, launched ads: https://en.m.wikipedia.org/wiki/Google_Ads

2001, profitable: https://www.theguardian.com/technology/2001/aug/08/internetn...

> Our package-lock.json specified the stable version 1.3.2 or newer

Is that possible? I thought the lock files restricted to a specific version with an integrity check hash. Is it possible that it would install a newer version which doesn't match the hash in the lock file? Do they just mean package.json here?

With binary vectors, 20 dimensions will get you just over a million concepts. For a billion you’ll need 30 questions.

> they often automatically pluralize, with the predictable result of seeing tables with names like addresss.

This is a very poor example, that case is literally in their unit tests file:

https://github.com/rails/rails/blob/b0c813bc7b61c71dd21ee3a6...

That test has been there over 18 years!

Agreed. The article makes many references to how life would be better with explicit well-defined interfaces… but types are how we explicitly define interfaces.

For example, Rust borrow checking isn’t to add complexity, it is to make it possible to explicitly define lifetime bounds in interfaces.

“Incomplete” seems like a better word than “incorrect” for this. The code is likely correct in the narrow scope it was needed for, but is missing features (and error checking!) beyond the happy path, making it easy to use incorrectly.

These UI elements (including the keyboard!) already blur their background, so that’s not a new cost. My 5 year old phone handles those fine. The distortion looks fancy, but since the shape of the UI elements is mostly-constant I’d expect them to be able to pre-calculate a lot of that. We’ll see when it ships!

Here's an attempt at that: The GPU is responsible for blending layers of the interface together. Liquid glass adds a distortion effect on top of the effects currently used, so that when the GPU combines layers, it takes values from (x + n, y + m) rather than just (x, y). Energy efficiency depends on how much data is read and written, but a distortion only changes _which_ values are read, not how many.

> Whereas complexity is a measure of how far ahead I can reasonably expect to calculate

So complexity is something like: high branching factor after culling “obvious” branches?

I suspect there is some /sarcasm in the parent post, the “techies” have already shipped crypto public ledgers which these scam sites use to steal their victim’s funds. Can it be sufficiently de-anonymised to do this analysis?

That’s one of the interesting things about innovation, you have to believe that things are possible before they have been done.