hresvelgr

I think "Black boxes are back in fashion" is missing the point. I think LLMs are still largely black boxes, and I don't think chain of thought is representative of any degree of inner machination. Asking it questions to justify itself is at best a facsimile, and for the most part it's useful, but it's fundamentally a facsimile.

Where I understand Jev to be a significant jump is that afaik the confidence scoring is actually derived from the normalised probabilities, and not a continuation in a chain of prediction masquerading as "confidence."

Twitter for reply guys? No thank you.

The Empire meets Star Fleet and the US Navy

> A study from Scotland

This is not a snipe, please go outside. Take some deep breaths, be around some flora, and fauna. This kind of cynical non-sequitur tells me you're looking for something to be frustrated at.

I'm not worried about these models becoming smarter, I'm worried about them becoming faster. Chat Jimmy is a glimpse of a dark future where models equivalent to Sol and Fable are unleashing hell at >17,000 tokens a second, and the people I talk to are worried about slop...

LLMs will accelerate the proliferation and searchability of ideas. Many times I've been using an LLM and it'll suggest ideas I would have never come across naturally that have been beneficial to whatever I happened to be implementing. For learning in general, it's been the most delightful tool I've ever used.

On the other hand, if you're working in an industry where you and your coworkers are developing novel solutions that aren't widely known, chances are you'll still be doing that by hand with some light LLM automation. There are industries with a lot of gatekept secrets where LLMs will be less useful. What I will say on that matter is this: if you weren't surprised frontier labs stole copyrighted work for training data, you'd do well to mind what you push through their systems.

It consolidates a lot of really annoying nits and quality of life aspects like bundling, module resolution, testing, env handling, etc. Node is just the runtime and still would require libs like esbuild, jest/vitest, dotenv, and so on. It's genuinely nice to have those out of the box, and generally in Bun the performance is quite significantly better in places that matter.

I have tried memorisation systems like Anki, but nothing, and I mean absolutely nothing consolidates my knowledge better than writing the actual concept down with pen and paper.

Commercially speaking, going against Git is a fool's errand. As much as I'd like to see Git usurped, I can't imagine the people backing this would sign off on a competitor to Git unless it was some type of sidecar. No doubt it'll be tightly coupled to Zed as well which is concerning. Perhaps this is pessimistic but I don't have faith the team are going to deliver anything groundbreaking given their entire business is existing technology, but less shit. No one is going to move core infrastructure for less shit or slightly better, otherwise we'd be using Mercurial or Darcs.

There are 3rd party ads in Discord now, and they are probably going to expand as an ad platform. I think this is what the parent comment was upset about.

edit: grammar

Backrooms is a cultural artefact that was created in the commons. The idea of any degree of ownership is nonsensical and it's ludicrous they tried.

> Same goes for memory management: you can do it manually, and it might work out most of the time, but if the programming language is helping you with it, the likelihood of memory safety issues decreases drastically. And the problem with avoiding these issues only by "meeting certain standards of rigour" is that you might only find out that you have failed to meet them years later, when you learn that your software has a vulnerability.

Zig does help you. Array slices, explicit nullability of pointers, defer errdefer, explicit allocators, built-in leak detection, bounds checks, overflow detection, the list goes on. If you need to play around on that side of the fence, Zig gives you a lot to make sure you don't mess it up. If we were talking about C I'd give you your flowers, but we're not. The most common issues and vulnerabilities that crop in C from manually managing memory are strongly mitigated by a quarter of that list.

> People tried to "just do that" (write their programs in a memory safe way) in C and other languages with manual memory management for decades, and we have countless vulnerabilities that prove this simply doesn't work.

Who are these "people" you speak of? It's possible to write software in low level languages that don't have these problems. Not a "non-zero" it might be possible, it can be done thoughtfully, and the popular notion it can't be done is backed only by incomplete anecdotes.

Should everything be written in low-level languages? No, that would be absurd. Is it a simple fact of life that not every person/team/organisation is capable of meeting certain standards of rigour? Yes. That's not to say anyone in the Bun team could not become sufficiently competent in the future. For whatever reason, current experience, incentives, and personal motivations did not make for a conducive environment to make Bun watertight in Zig.

> You can just do that, and then Zig is really no less robust than Rust.

That's just it, using Zig required more rigorous engineering than the Bun team were capable of.

In the figurative sense it's highly versatile across contexts, but still replaceable. For example:

"Her optimism was load-bearing,"

versus:

"Her optimism was enduring."

Exactly the same meaning and connotation. It stands to reason that the terms with the most semantic flexibility will have preference across all contexts. So in response to:

> maybe we should be learning from Claude rather than complaining.

I'd say let's not steer ourselves into regular language and keep some vivacity in our expressions.

Both points are specious. C disassembly is usually not an orthogonal translation of the structures in the code, usually due to optimisation.

> In C you have loops, functions structs. All things that make no sense in assembly.

One can reasonably infer that a loop will roughly translate to some type of conditional jump instruction. Function structs are just pointers and call instructions. The former point was that there is little runtime getting in the way of how the constructs could be expressed, and a long time ago it may have been the truth, but not for modern compilers.

The condition that made this possible is that this task is well within frontier LLM capability and he had tokens to burn. Domain knowledge is separate to language semantics.

> Except that said AI can now themselves use your software and find and fix bugs themselves, not to mention drive new features.

Anyone with sufficiently good taste in how to program effectively and architect will disagree with you on this. The short leash method is how you ensure good results when you're functioning outside of the training data. If you're even a modestly above average programmer this is afaik the only way to ensure fast, quality development with LLMs.

> This again feels outdated. I think we're mving towards humans no longer needing to understand a codebase, and letting AI drive it.

I think you are perhaps unaware of a world of programming where AI is still woefully inept. I have observed very consistently in all languages with manual memory management frequent issues with handling it. Trust me, it's not as simple as sticking it in a loop with Valgrind.

I think the irony here is that LLMs are the ultimate tool for auto-didacts and people who love to learn independently, bar none. Using them to cheat is such a profound waste to me. I've beeen able to accelerate my learning thanks to LLMs, and it saddens me that the potential for this kind of personal enrichment is lost on most.

Stealing for me, but not for thee.

> Ginger Bill, the Odin language developer, is openly hostile against package managers (he wrote a post called "Package Managers Are Evil") so he maintains his own wrappers of popular C libraries in vendor folder next to the compiler. That doesn't sound like a healthy ecosystem to me.

There are good reasons for this (supply chain attacks, dependency hell), and while Odin doesn't have a package manager it does have a concept of a package. There is nothing stopping anyone from downloading and adding them to a project, in fact Odin developers do this already. The Odin core library is absolutely massive and contains a lot of what you would need for most projects, vendor rounds it out. The purpose is to be batteries included so your project doesn't have to rely on as many dependencies.

> I think zig is also highly opinionated but it always seemed to me that Andrew started from solid pillars

It's funny you say that, because I hold the same stance for how Odin was constructed, and the examples listed hold for Odin too. There is a lot about Odin's design that is consistent with Zig. Check it out, you might be surprised ;)

> Odin on the other hand is just some developer's personal taste marketed as "Programming Done Right". So, if you disagree with any choice Bill made, you're not doing programming right.

What do you think every programming language is trying to do? Solve the issues of the author. Bill has strong opinions about programming, so he made a language and a reasonably successful one at that. Given the swathe of people who would just complain, it's refreshing when people try to instead better the world relative to their values. Say what you will, he does it because he cares.

Another language that is in a similar space to Zig that I think deserves more attention, particularly for funding is Odin. While I think Zig is a great language, there is a consistency of design and simplicity to Odin that makes low-level programming more ergonomic and enjoyable to me. While Zig boasts a lot of impressive projects, Odin was used to build the JangaFX suite[1].

[1] https://jangafx.com/

Great work, the examples look fantastic. I will say, it's misleading to put "without AI" in the title for you to then comment on your submission that you have in fact used it. While it may only be in a trivial capacity, you've still used it.

Most human editors are not given credit, why would it be any different for an LLM?

Ironically, Git is my preferred VCS. I have used Perforce Helix, Mercurial, and SVN. It is the best of the worst. I don't think anyone in the space has made a truly great product.

I see a lot of people trying to capitalize on GitHub's recent failings, and I feel like everyone trying to shoot their shot in this space is missing one key aspect: Git is a terrible TERRIBLE piece of software.

I have spent a considerable amount of time learning git, not because I wanted to, but because someone else in my team didn't and inevitably t-boned our repository with a proverbial freight train running commands they didn't understand. It is absolutely unacceptable for a program designed EXACTLY for the purpose of maintaining a history and backup of the evolution of a program to be so unwieldy and occasionally dangerous to use. We can absolutely do better than Git.

The new Toyota Prius looks better than this. I know beauty is in the eye of the beholder, but if Ferrari is being outdone on design by a common commuter vehicle it looks terrible.

This is a similar argument to "Dropbox is a feature, not a product" and it definitely rings true in this instance too. I remember the litany of applications that only supported sync through Dropbox. It had no ecosystem, it's saving grace was that no one yet was operating a service similar at that scale.

All the major AI companies are trying to manufacture their own ecosystems to become less disposable. They'll get away with it for a while, but only insofar as hardware prevents advanced use. Once we get that hardware[1] there will only be two types of AI companies: hardware manufacturers, and labs. Just like sync became trivial and ancillary, so will AI inference.

[1] https://taalas.com/the-path-to-ubiquitous-ai/

Am I the only one who thinks Obsidian is perfect without plugins? Half the reason I switched to it from Anytype was that it was rather spartan in its offerings. If they announced tomorrow they would ban plugins, I would not care.

I would encourage everyone remotely interested in Zig to have a look at Odin[1]. If like me, you read that article and found yourself muttering "what the hell," then you might appreciate Odin's simplicity and design consistency.

I am definitely in the minority here, but I am not a fan of the kind of meta-programming that Zig and Rust offer, with Rust being especially atrocious. In the two decades I've been programming I can count on one hand the number of times meta-programming was an appropriate solution to a problem I had. Every time I reached for it, I got bit. There's a reason "when in doubt, use brute force" is sage advice, it may not be fast and glamorous, but it'll be a hell of a lot less opaque.

[1] https://odin-lang.org/