[silisili]

That's kinda my experience with watching Zig. It went from 'look how simple this is' to 'look at this new feature syntax' long ago.

People used to compare it as simpler than Rust. I don't agree that it's simple anymore at all.

None of this is meant to be badmouthing or insulting. I'm a polyglot but love simple languages and syntaxes, so I tend to overly notice such things.

[Laremere]

The computer is a machine, and modern ones are complicated. When I am programming, I want to precisely control that machine. For me, simplicity is measured in how complicated it is to get the machine to do what I want it to do. So, eg, having several different operators for adding two integers sounds complicated. However there is simplicity in not having to reach far to actually get the correct behavior, and there is some simplicity in the process of being forced to make that choice as it irons about what behavior you actually want.

[silisili]

I think that's long been the argument of simplicity. 'Simple to remember' vs 'simple to perform.'

I tend to fall into the former camp. Something like BF would be the ultimate simple language, even if not particularly useful.

[lewdwig]

Structured concurrency is a notoriously hard problem. This is part of Zig’s 4th attempt to get it right.

[throwawaymaths]

the only two new feature syntaxes in about six releases have been multiple iterations in for loops and continue in switches? maybe reified tuple types too (not just implicit) and destructuring tuples.

a few things have been removed, too. and async/suspend/nosuspend/await, usingnamesplace are headed for the woodchipper.

[raincole]

Rust will be (already became?) as complex as C++, if not more. Zig will be as complex as early rust. It's like a force of nature.

[tialaramex]

How do you figure Rust is "as complex as C++" ?

[pjmlp]

I guess, two macro systems, ML type system, affine types, crates using nightly features, having a hard time keeping up with every six weeks feature drops.

[tialaramex]

I get two macro systems, but a coherent type system seems simpler to understand. The existence of "regular void" proposals seems to underscore that the "easy" C type system's incoherence doesn't end up being easy to work with or reason about.

And I don't see "crates using nightly features" as somehow a language complexity. Are we counting "Three different compilers with their own quirks" as a C++ complexity? Nor is the six week cadence a complexity. When naked functions stabilized a handful of people went "Hooray" and nearly everybody else doesn't care. And that's not even a feature in standard C++. You have to go read your vendor instructions and do it separately each time. "Yay!".

[pjmlp]

I like both languages, those are the issues where I see someone looking from outside and having such complexity claim as the OP.

The ecosystem is part of what means to use a specific language, though.

Yeah, having to guess what standards and extensions each C and C++ compiler implement, is also an issue with them, and will eventually come to Rust as implementations eventually come up, originally there was only CFront and UNIX System V compilers.