Use after free is a reality in Zig.
Use after free is a reality in Zig.
Zig also has bounds checking, and is null safe: these are important ingredients in spacial and temporal memory safety, respectively. The bounds checks can be turned off, but length is part of an array type, and slices include the runtime length, so it's still doing much better than the classic degrade-to-pointer you get with C (C++ doesn't use arrays much but it shares the problem in a more complex way). Runtime safety can be turned on and off on a per-block basis, which in the right hands gives fine-grained control.
Which isn't to say you're wrong: in Zig, you manage memory, and that means that memory bugs are not only possible, but they will happen and must be found and corrected in testing. But saying it's "just like" C and C++ is pushing it imho.
Zig is aiming to make memory bugs as easy or hard to detect as ordinary logic bugs, the kind of thing which it's tractable to detect and correct for with rigorous testing. It also has much better support for arenas than any other language, since allocators are explicitly passed: this can conglomerate potential memory bugs into one point in a program's execution. There are more features like this than I can feasibly fit into a Hacker News post.
Saying that Zig is not a memory-safe language is just correct. But it's possible to write memory-safe code in Zig, to say otherwise would be like claiming that you can't traverse a tree in Python because the language won't help the traversal code be bug-free by construction.
The leading example is TigerBeetle, which chose an architecture which statically allocates all memory on load. This prohibits any temporal memory safety problems, leaving only spacial memory bugs as an option. TigerBeetle insists on no bugs at all, and is willing to do the enormous amount of testing which is necessary to get any amount of confidence that the goal is accomplished.
There's a place for a language with manual memory management, which instead focuses on easing the extreme pain and pointless difficulty of writing memory-correct code in C. Zig is doing a great job of becoming that language.
But I know, those curly brackets make all the difference.
Random integer promotion rules, weird puzzle-like type declaration rules, the macro mess, the crazy WG14 reasoning in general.
No, use after free was NEVER a problem.
So Zig solves problems I had with the language instead of trying to force non-problem solutions on me.
C++ came up with a few consistent language-level RAII-based solutions to the problem. Rust came up with a single big consistent language-level approach. Both Rust and C++ insist on using it in all cases.
What Zig does, and which I like, is that it refocuses the language on tools that make it easy to codify the right thing without making it a cornerstone of the language itself. But without introducing the kind of complexity C++ (and Rust to an extent) is famous for.
Much better than raw C, but still it leaves things to be desired in the context of safe systems programming.
The thing is: people don't want everything.
For the kind of things that are expected to be build in C and C-inspired languages it just doesn't make sense to have Lisp-like macros, or 2 flavours of macros like in Rust, or the accidental kind of metaprogramming C++ is famous for.
Comptime does the job just fine here, replacing the unpredictable macro mess.
https://news.ycombinator.com/item?id=41723448
https://news.ycombinator.com/item?id=41717757
We have to ban accounts that post like this. I don't want to ban you, so if you'd please review https://news.ycombinator.com/newsguidelines.html and stick to the rules, we'd appreciate it. That means thoughtful, respectful conversation, regardless of how wrong others are or you feel they are.
Edit: I took a look at your recent comments and you don't seem to be in the habit of doing things like this (that's good!) so it should be easy to fix.