> 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.
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.
> 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].
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.
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.
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.