Mond_

It's not about having to remember them, it's that you shouldn't waste these short single symbols on operations that are only rarely used.

This stuff (especially the ternary) are a step backwards. There is just no reason to waste | on a bitwise or that gets used at 1% of the frequency of the standard or. In the future you might have a better use for it (pipeline syntax, sum or union types come to mind in other languages).

I dislike basically everything about these syntax extensions.

Money can't buy happiness, but it can buy less unhappiness

Money can very much buy happiness. Most of the things that make you unhappy can be remedied with money

Was it too hard to read beyond the first comma?

It's their own blog and they can do whatever they feel like to break up the flow. I think it's quite charming tbh

Sort specifically is kind of a weird example, but C++ is full of awful naming.

std::map (which is not a hash map, which is what most people would expect), std::move (which doesn't move), std::vector (which is not a vector), and std::vector<bool> (which is not even a std::vector).

Yes, with the trade-off of essentially requiring exceptions, which are also banned in some codebases.

Is it really, though, or is it just in comparison to C++?

Tbh I never expected that experiment to go anywhere. I guess that leaves Carbon (and large scale efforts to rewrite C++ in Rust).

May I ask how far you got? It's not a good representation of industrial engineering, for sure, but I do like the actual logistics management and "how do I deal with my technical debt" later in the game. I think most of this only really gets interesting once you use trains everywhere and build everything with bots.

It isn't anymore, though, that's kind of the whole point of the article.

Strategic vision.

The common sentiment is that you didn't really want to do that. You expect higher returns from only having a single base model.

How about just panic? If a wrap happens and you don't expect it, it's almost always a severe bug.

Then, dedicated APIs for wrapping behavior where you expect it to happen.

Not OP, but I've had the same conclusion. It's a bit cheeky to call it a puzzle game, but I don't think it's strictly wrong.

Imo it's better to approach Demon's Souls as an exploration puzzle game with RPG stuff and combat, not as an action RPG (such as Dark Souls 3).

No shade thrown, but I always preferred my game with some amount of story or artistic ambition beyond mere puzzling.

I'd take Void Stranger or probably even Deadly Rooms of Death: The Second Sky over Stephen's Sausage Roll any day, I imagine.

I don't think that's what that word means.

really?

So, where can I buy a handful for personal use?

I think that a "minimal viable baseline" type implementation should not break the ODR.

In Rust these types of proposals are common, in C++ less so. The incredibly tedious release process encourages everyone to put in just as much complexity as they can safely get away with.

Well, I've been unable to follow you as well, then. Obviously if they'd used a different type of syntax (e.g. using # for annotations), those would also be compatible with the language spec, and other implementations would still be just as capable of ignoring all unknown annotations.

(Though for the record, talking about alternative implementations when discussing Go is kind of a funny joke.)

It's an overloaded comment. I am personally quite fine with it, I don't think it's bad. but it is an overloaded comment.

This is begging the question. Yes, but why did they do that over dedicated syntax?

(My personal theory is that early go had a somewhat misguided idea of simplicity, and preferred overloading existing concepts with special cases over introducing new keywords. Capitalization for visibility is another example of that.)

This is such a silly response when "You've gotten better at using them and know how to work around their flaws now." is right there and seems a lot more plausible.

Manjaro sells itself as "Arch, but more approachable". In reality, you'll often end up with "Arch, but with additional weird package management upgrade issues that are a byproduct of Manjaro's own repositories interacting with the arch on your system."

Instead of just having to track the arch repos, you suddenly have those and Manjaro's own stuff (and own package manager tool etc.), which is another point of failure. Every new bit of technology is another part that can fail.

I used Manjaro for a few years.

That's how I learned a pretty important lesson about software engineering that still informs how I work to this day.

"A layer of abstraction on top of a stateful legacy system often doesn't result in a simpler system, it just introduces exciting new failure possibilities. This especially applies when the owners of the legacy system have no responsibility over the abstraction layer."

I think a lot of the really old school people don't care, but a lot of the younger people (especially those disillusioned with C++ and not fully enamored with Rust) are in fact quite happy for C to evolve and improve in conservative, simple ways (such as this one).

The tradeoff Go made is that certain code just cannot be written in it.

Its STD exists because Go is a language built around a "good enough" philosophy, and it gets painful once you leave that path.

Bad news, John Google told me they already quantized it immediately after the benchmarks were done and it sucks now.

I miss when Gemini 3.1 was good. :(

OpenAI has a whole history of trying to scoop other providers. This was a whole thing for Google launches, where OpenAI regularly launched something just before Google to grab the media attention.

why call him that when "saltman" is right there

It's worth pointing out that the two examples that you're writing are actually strictly different, and not just "better syntax for the same thing". (This is assuming `String | Int` works as in Python, and the second example works as in Rust.)

To understand the difference, `String | String` is just `String`. It's a union, not a sum type. There's no tag or identifier, so you cannot distinguish whether it's the first or the second string.

If this sounds pedantic, this has pretty important ramifications, especially once generics get involved.

Sounds like it might be an issue with your setup, considering that other people have no problems running it. Hard to tell what the problem is, but definitely a frustrating situation.

I love how the haters of Rust's syntax can be roughly divided into two groups:

(1) Why doesn't it look like C++?

(2) Why does it look so much like C++?