juancn

And that's a HUGE issue. SSH keys are easy to manage in comparison to PassKeys.

So?

We have information that Fable was distilled from humans.

If it works it works. Isn't that the argument?

AI outputs are not copyrightable, so distillation is fair use.

It may be a TOS violation, but that's a private matter. Cancel the accounts used for distillation and be done.

How? Where are they stored? Which password protects them? How do I back them up? How do you move them to another device? Can I print them out on paper as a last resort measure?

Nobody fucking knows.

A password has the best recovery process. Period. Write it down somewhere. It's up to me, no third party.

I had more trouble with a failed 2FA than with a password.

I would feel a lot better using SSH keys rather than passkeys. At least those are understandable.

What if I lose all my apple devices? House break-in and they steal my mac and my phone?

You're basically fucked even if you buy a new one because you need one of the other two to log in.

Same here, also what if I lose the device?

I can safely write down a password on a piece of paper and keep it somewhere phyisically safe.

Passkeys and 2FA are a usability nightmare if you need to recover, or all the security vanishes if you put usable recovery mechanisms for the passkey or the second factor.

It's too conservative, on my Air M4 I run gemma-4-12B-it-qat-UD-Q4_K_XL fine with llama.cpp

The app states "Small Models (1-3B)".

You can run it in JSLinux if you don't want to risk it running locally:

Go here:

https://bellard.org/jslinux/vm.html?cpu=x86_64&url=alpine-x8...

And run:

    bash -c "$(curl -fsSL https://alganet.github.io/terminal/index.sh)"

Yeah, thanks!!

Excellent article! I think it has the right level of detail, one question though: why the shape of the tensor? 4x8x11.

That I didn't get from the text.

Interning can be really helpful.

In the early noughties I worked in a compiler in Java, and using String.intern() at the lexical level helped a lot with compiling speed and garbage generation.

It can be a neat trick, since you do it at lexing time and you speed up any subsequent String.equals() call.

It was particularly important for us because we called it very often in an IDE in the editor for error highlighting and auto completion and you want sub-300ms responses or it feels extremely slow.

Machines at the time were under 1GB of RAM and fairly slow

TLDR AI Summary of the thing:

https://gist.github.com/juancn/9bc654ccffbba113271a068a2d854...

(I found the flourished language of the original a bit too much for my taste)

I already had a DSL and with a proper prompt and a checker tool, even tiny LLMs could build really good scripts in that language. Gemma 12B QAT was excellent.

Actually the tool-calling convention is a small DSL too.

I suspect the DSL ideally has to be similar to something in the LLM's training set though.

It doesn't have to feel too alien, otherwise the description of it has to be thorough and will eat up a lot of context.

Frontier models don't suffer as much of this limitation since they can grab onto a larger corpus of knowledge, but they're expensive.

Nice!

Why not just go full character mode?

The smooth motion is nice, but a bit of overkill, also it adds complexity to the collision code.

I suspect this can be done using a variation of Bresenham's line algorithm for the trajectories (keeping delta X and delta Y for each ball) and avoid most/all of the complex trig and math. Just addition and subtraction and a few sign changes.

The delta can be kept at a higher resolution than the grid (i.e. 16x so a mask can be used instead of division), so you can fudge the collision with small delta changes on impact using the SID as a RNG.

Battery life is shorter, and some are a tad heavier.

Doesn't just emacs render to a tty?

Or is this for some Emacs build with its own renderer?

Effort. AI is low effort, which signals you really don't care, you're out there for a quick buck.

It's insulting. It makes people feel irrelevant.

Apple doesn't like to be held hostage, it has the cash coffers, so it wouldn't surprise me if they're somehow buying dedicated production capacity for the future.

Not that they will start making memory themselves, but they have bankrolled production expansions in their suppliers before in exchange for guaranteed supply.

In any case, if my guess is right, it would take years to take effect.

90% of my model use is on local open-weights models.

The things that I need to automate do not need frontier models. Heck, even a gemma-4-12B-it-qat-UD-Q4_K_XL can deal with a lot of complexity if properly guided (it can run on 16GB of unified memory, for example on a base model Macbook Air).

I've been using it to translate Javascript to a custom scripting language in a product I work for, just by providing a system prompt and an MCP tool to call the target compiler to check for errors.

Sometimes it converges faster than Opus 4.6 (I've tried) because it doesn't over-think stuff.

If it were a person I would say it knows less, but it's still smart.

I mean, you don't need the most powerful tool at all times. We treat AI as one-size-fits-all, and once cost gets in the way, it will matter.

All leadership is like that. Even if you're not a people manager.

I'm an IC in a technical leadership position, all of these hold true with the added constraint that I cannot tell anyone what to do. I hold no carrot or stick.

I have to persuade, convince and influence, I have no reports (nor I want them) so to get anything done I need to get people to align and understand the value on its merits.

That's always an issue, but the industry seems to be moving away from 2D circuits.

Reducing trace length seems to be the way forward for faster/larger circuits. Signal propagation time on-die is becoming an issue.

Things like Huawei's Logic folding, or TSVs, and so on, attack the issue by reducing signal travel time.

This looks like another building block in that direction.

There's also some push at cooling chips from both sides.

Yeah, but it was probably the right call at the time.

Backward compatibility was a breath of fresh air at a time were code needed constant porting and rewriting. No two machines were alike.

It's one of the reasons the PC became so popular.

Everything is within spec, reproducible builds are not a goal of C/C++.

The compiler builders may take pity on you, but really there's no bug here, just unwarranted expectations.

It's still too unpredictable trying to be transparent IMHO.

Scalarization can fail in surprising ways just due to what a maximal atomic write can be on the target platform, and then it fall back to heap allocated objects.

Even if there's type erasure.

I much rather have the compiler balk at me than let me write something that may or may not work as expected.

The triple click is annoying.

I mean, select the word, then press check, then press continue.

It could be one single click and move to the next, show me my last result at the same time you ask me for the next one.

The influence has spread wide, there's one even in Buenos Aires: https://buenosaires.gob.ar/gcaba_historico/jardinbotanico/la...

I'm trying to figure out exactly how to best use AI, but not just as a chatbot user.

How to integrate it to solve useful problems. Make delightful products.

So many things that used to be intractable now are probabilistically solvable and that needs some things to be changed fundamentally and a lot of assumptions dropped.

The randomness that AI introduces poses a plethora of challenges.

I think local models will be a big thing eventually, not everything needs a frontier model and a lot of useful work can be done with surprisingly little hardware.

I also want to get back to non-LLM models.

It's like the e-everything trend of the 90s.

It's pushing an internal tech detail onto customer faces that only care about a problem being solved.

It's virtue signaling for investors and a usually misguided attempt to look trendy or cool.

It's kinda like that, there could be a proprietary fraud detection heuristic in there that you don't want to get out.