One last thing on the Vim emulation front: While I'm not a big fan of VSCode, the VSCode-Neovim extension[0] connects to an actual Neovim instance via Neovim's MessagePack-RPC API, allowing you to use real Neovim but native in VS Code. Pretty cool!

0: https://github.com/vscode-neovim/vscode-neovim

I am primarily an Emacs user, using the standard key bindings (and a whole bunch of custom bindings and functions I've built on top of it over the decades, ctrl remaped to caps lock and no Emacs pinky so far).

But I am also 80% a NeoVim and Vim user for about 15 years now, and I consider myself quite proficient with Vim keybindings. The Emacs emulation is truly incredible, but the fact that Vim implementation quality varies wildly from environment to environment is extremely frustrating to me. For example, the jupyterlab-vim plugin is so jarringly broken in a handful of ways that it completely knocks me out of the flow of whatever I was doing when I encounter those emulation failures. IntelliJ's idea Vim plugin is a pretty decent one, but even there I have encountered the occasional issue [1][2][3]. Otherwise, I strongly agree with your point about learning one way to work with text and being able to leverage it most places.

Sort of a tangent, but I think this is why Emacs users tend to end up trying to do as much in Emacs as possible: It's not really the keybindings but the fact that everything in Emacs is a text buffer. Emacs owns the input and the output, and because everything in Emacs operates on text, you can do most everything in most every mode, to most any buffer content. One example of how powerful this can be is the ability to press a key and use dabbrev-expand to autocomplete shell input I'm typing based off the shell output of a prior command.

1: https://youtrack.jetbrains.com/issue/VIM-569

2: https://youtrack.jetbrains.com/issue/VIM-636

3: https://github.com/JetBrains/ideavim/pull/33

I wish more of the web were like this.

    2012 MacBook Pro
    2015 MacBook Pro
    2019 MacBook Air
    2020 M1 MacBook Pro

This is also a good point, and I agree with you 100% here. I don't think one could responsibly argue that the impact and consequences are not significant, regardless of if they believe it's near AGI or it's just fancy next token prediction.

"It's just a four wheeled platform powered by a box of controlled explosions" isn't a terribly useful description of a car until you get into a conversation with someone who thinks their car is depressed because it spends most of its time locked up in a garage.

I am not actively pointing my LLM at the kernel in the specific way that would uncover these bugs, and just because it's possible to do so doesn't mean that it has happened already.

> the policy wasn't made on a whim. to quote the linux security team [...]

Great, so let the ones that arise simultaneously do so. What does that have to do with immediately publicizing a vulnerability, regardless of severity, just because an LLM was involved in its discovery?

> the term responsible disclosure is a silly thing made up by vendors

That's certainly an opinion you're welcome to have, but unless you are proposing that responsibility and disclosure are two orthogonal concepts I don't see what that opinion has to do with anything I've said.

    uv pip install -r requirements.txt --exclude excludes.txt

    pandas
    scikit-learn
    matplotlib

    numpy

EDIT: You can also configure this for uv directly in a pyproject.toml file:

    [tool.uv]
    exclude-dependencies = ["numpy"]

Is this true for coding tasks? Genuinely asking because I don't yet have the hardware to be able to run/compare. I thought I remembered the sentiment that the 27B dense was better than the 35B MoE

Q = XW_q

K = XW_k

V = XW_v

From there, you can think of K and V like keys and values in a Python dictionary, and Q as the key you pass (e.g. d[Q] in Python to return some value V). The difference in an attention layer is that the query is matched to each key using a dot product, and rather than getting a single value back you get a weighted sum of values.