mwcampbell

I wonder how you arrived at that number. Is it perhaps a number that we should aspire to, if we want to write high-quality, maintainable code by hand?

once the RAM bottleneck passes

Do we have evidence that this will actually happen? Maybe the belief that it won't pass is what requires evidence, but I think there's a widespread feeling right now that things are just getting permanently worse and this is one example.

Compiler developers didn't hoover up as much human creative work as they could, legally or not, to evolve a giant inscrutable thing that does what it does probabilistically, with the explicit goal of replacing as much human labor as possible for the enrichment of the already rich. Whatever benefits we get out of generative AI are just a side effect, and one that may not last when the investors stop subsidizing our access to the big models.

Well, the frontier models aren't freely available in the same way that the training data (the public web) is; they're only available as a limited no-cost tier of a paid service.

There are models where the weights are released and you can run them locally, but one counter-argument I've seen is that these aren't really the models that people are excited about and making extraordinary claims about.

Rust with wxWidgets via wxDragon has recently become a viable option for some kinds of apps. It even has dark mode now. wxWidgets comes with a disappointing amount of bloat though.

I invested about $4,000 in an NVIDIA DGX Spark several months ago. 128 GB of unified RAM, and the NVIDIA GB10 chip. With the RAM, the several CPU cores, and the 4 TB NVMe SSD, it's a very capable ARM64 Linux computer even without the GPU, and so far I've mostly been using it as such. But I wonder, what's the most capable model, specifically for coding, that can run well on that hardware?

Have you found evidence that the code is actually low-quality, or is that just an assumption based on the fact that it's evidently largely LLM-generated?

IMO the word "compute" is too generic here. To me, the most valuable thing that personal computers have brought us so far is the ability to communicate smoothly across (dis)abilities through digital text. Think of a blind student writing an assignment that can be read by a sighted teacher, or a sighted student and a blind teacher, with no transcriber mediating between them, and a blind writer being able to know what they're actually writing and correct it (as opposed to, say, using a typewriter blind). We should be able to do that, with a variety of assistive technologies for different disabilities, with far less computing power than we're using now. Edit to add: And indeed we did, decades ago, including in battery-powered devices. But now we're convinced that our "one device" needs to be able to do everything, thus it needs to have as much computing power as modewrn technology allows.

Edit 2 to add: I think it's important to be specific about what the computing is for. If you just need to solve a small number of equations, then yes, you can do that with a slide rule. But in the written communication case above, the computing is only useful when done with at least the speed of an early microcomputer and paired with digital storage and/or networking and a variety of I/O devices. Still, we don't strictly need our modern supercomputers for that use case, except that it's now considered weird and limiting to use anything less. Also, I bring up the written communication use case because there is a rising backlash against allowing personal computers at all in certain contexts, such as education, because of AI-based cheating. I don't want disabled people like me to lose what we've gained from personal computing in the specific use case I described above. Maybe the solution is to normalize using less than a maximally powerful, Internet-connected personal computer in such contexts.

Are there any models that are specifically trained to produce diagrams as SVG? I'd much prefer that to diffusion-based raster image generation models for a few reasons:

- The usual advantages of vector graphics: resolution-independence, zoom without jagged edges, etc.

- As a consequence of the above, vector graphics (particularly SVG) can more easily be converted to useful tactile graphics for blind people.

- Vector graphics can more practically be edited.

“A healthy man has many dreams. A sick man has only one.”

I'm partially blind, and I know many fully blind people. None of us have being sighted as our one dream.

That's fine, if we only care about ourselves. I guess the harder part is convincing everyone else to unplug from mass media and not raise their kids on it.

Then maybe we need to kill mass media once and for all. Keep the global communication network, but let it be all small-scale communities.

Your argument presupposes that we should accept escalating baseline hardware requirements as good or even necessary, for a desktop computing world that was, from the user's perspective, doing pretty much the same thing as before. I reject that.

Yes, text shaping and layout are complex. My point is that the program wasn't doing anything that should have required a GPU, particularly for the resolutions that were common back then.

WPF was good

As someone who saw what impact WPF had on average users running average hardware in the late 2000s to early 2010s, I disagree.

In 2011, my brother was in seminary, using an average Windows Vista-era laptop that he had been given in 2008. When he was home for Christmas in 2011, we were talking about his laptop, and he told me that the Logos Bible software ran sluggishly on that laptop. He said something about how, for reasons unknown to him, the current version of Logos required advanced graphics capabilities (I forget exactly how he phrased it, but he had learned that the slowness had something to do with graphics). Bear in mind, this is software that basically just displays text, presumably with some editing for adding notes and such. At the time, I just bought him another laptop.

A few years later, I happened to read that Logos version 4 was built on WPF. Then, remembering my brother, I found this Logos forum thread:

https://community.logos.com/discussion/6200

This shows that Logos users were discussing the performance of Logos on machines with different graphics hardware. For a program that was all about displaying and editing text, it shouldn't have mattered. WPF had made a bet on then-advanced graphics hardware for reasonable performance, and that was bad for these users. And that's just the one example I know about.

Yeah, I see what you mean now. Sorry.

DTrace was absolutely a product of pre-Oracle Sun, not Oracle.

I hope we can still get to a point where wasm modules can directly access the web platform APIs and get JS out of the picture entirely. After all, those APIs themselves are implemented in C++ (and maybe some Rust now).

Boilerplate and scaffolding

Have we really reached the limit of how much we can reliably automate these things via good old metaprogramming and/or generator scripts, without resorting to using unreliable and expensive statistical models via imprecise natural language?

Refusing to use AI out of principle is as irrational as adopting it out of hype.

I'm not sure about this. For some people, holding consistently to a principle may be as satisfying, or even necessary, as the dopamine hit of creation mentioned in the article.

We had Joel Spolsky saying that users don't read back in 2000, around the same time that Steve Krug published _Don't Make Me Think_: https://www.joelonsoftware.com/2000/04/26/designing-for-peop...

So was the learned helplessness already ingrained by 2000? How far back does it go?

Every little detail matters though. In SQL, do you want your database field to have limited length? If so, pay attention to validation, including cases where the field's content is built up in some other way than just entering text in a free-form text field (e.g. stuffing JSON into a database field). If not, make sure you don't use some generic "string" field type provided by your database abstraction layer that has an implicit limited length. Want to guess why that scenario's on my mind? Yeah, I neglected to pay attention to that detail, and an LLM might too. In CSS, little details affect the accessibility of the UI.

So we need to pay attention to every detail that doesn't have a single obviously correct answer, and keep the volume of code we're producing to a manageable enough level that we actually can pay attention to those details. In cases where one really is just literally moving data from here to there, then we should use reliable, deterministic code generation on top of a robust abstraction, e.g. Rust's serde, to take care of that gruntwork. Where that's not possible, there are details that need our attention. We shouldn't use unreliable statistical text generators to try to push past those details.

I disagree on Kubernetes versus ECS. For me, the reasons to use ECS are not having to pay for a control plane, and not having to keep up with the Kubernetes upgrade treadmill.

This idea is a major theme in this story by Robert Kingett: https://sightlessscribbles.com/the-colonization-of-confidenc...

the actual object-level question ("is this tool useful for this task")

That's not the only question worth asking though. It could be that the tool is useful, but has high negative externalities. In that case, the question "what kind of person uses/rejects this" is also worth considering. I think that if generative AI does have high negative externalities, then I'd like to be the kind of person that rejects it.

What's the name of this DLL? I assume it's separate from the monster chrome.dll, and that the model is proprietary.

Given that it's a 400B-parameter model, but it's a sparse MoE model with 13B active parameters per token, would it run well on an NVIDIA DGX Spark with 128 GB of unified RAM, or do you practically need to hold the full model in RAM even with sparse MoE?

Impressive work.

I wonder if you've looked into what it would take to implement accessibility while maintaining your no-Rust-dependencies rule. On Windows and macOS, it's straightforward enough to implement UI Automation and the Cocoa NSAccessibility protocols respectively. On Unix/X11, as I see it, your options are:

1. Implement AT-SPI with a new from-scratch D-Bus implementation.

2. Implement AT-SPI with one of the D-Bus C libraries (GLib, libdbus, or sdbus).

3. Use GTK, or maybe Qt.

Yes, exactly.

I actually do believe that AI is dangerous, though for different reasons than the ones he focuses on. But I don't think he really believes it, since if he did, he wouldn't be spending billions to bring it into existence.

This is obviously bullshit. If he were really worried about the things he says he is, he'd put the brakes on his company, or would never have started it in the first place.