My employer pays for Cursor and Claude but not Codex. I often find Claude dumb (yes, even Opus), thus I'm using Cursor with GPT-5.4. If you have Codex, you don't miss anything.

I think Blizzard did offer some jobs to the devs behind Nostalrius to work on then-upcoming Classic?

  Blizzard’s actual approach is much more sane: older content comes back in controlled ways.

Agreed. This is one of the things Blizzard actually nailed.

  I hope turtle open sources

Have private servers shared their work at all? I have a feeling that everyone is redoing everyone's work and keep it private out of rivalry.

I was involved in another mmo's private server scene- what happened there was the source code for servers would get released after a server is taken down (whether by DMCA, or just pure infighting), then people build on top of that, then repeat. I would say a vast majority of the source code is not released to the public.

Well, they did share their view and it's being discussed, so what's the problem?

When I saw the title, I actually didn't have much emotion beyond curiosity. But then after checking thus comment, it piqued my interest, made me step back and really consider the ramifications of how we got here. And then yes I became depressed also.

Anyway, I got value out of it, comments dont have to increase net factual information to be meaningful, because we are all capable of reflection.

No, they are not. Even ignoring business where using AI would have consequences for you (medical is one example), there are plenty "normal" software companies that value quality over slop.

My first impression is not great. Several clicks in the docs - no screenshots to see how it looks like. The very first thing advertised on their GitHub - some "#1 coding agent". And again - no screenshots. Some flashing unpleasant video. "Written in Rust", which is becoming a meme, like if a user should care.

Maybe it's a good file manager but, imo, authors completely failed to advertise it right.

What's fussy about AOT and reflection?

Only a subset of reflection is actually AoT safe, and you can run into issues like "the method you wanted to call wasn't statically referenced anywhere, so there is no compiled implementation of it".

That's due to trimming which can be also be enabled for self-contained builds that use JIT compilation. Trimming is mandatory for AOT though. But you can use annotations to prevent trimming of specific thing.

AOT doesn't support generating new executable code at runtime (Reflection.Emit), like you can do in JIT mode.

As the sibling comment says, it's an effect of trimming which you get even without AOT.

You choose on checkout. There it says

    Plan details

    5x more usage than Plus        20x more usage than Plus
    $120/month                     $200/month

So curious that the cost in the comparison is just a flat $100, not "$100 or $200" and yet the usage has the "or". Surely just a lapse in copy editing.

Surely they weren't trying to be deceptive... surely.

Anthropic is the exact same way, I think they're just trying to avoid having 5 different subscription tiers visible. Probably needing 20x is very niche

It states “From $100”. Standard pricing speak.

Unfortunately also standard pricing speak to make the "From" 20% the font size and decreased contrast. Maybe they learned it from car marketing.

Many tools can be misused. Object.Member can throw a NRE, is it a big mistake to have the dot operator?

It's such a weird question.

Yes, "dot operator can throw a NRE" is of course a big mistake. A billion-dollar mistake, you can even say.

No, I'm not asking if "dot operator can throw a NRE" is a mistake; I'm asking if the dot operator, the ability to access members at all, is a mistake.

One take on it is that yes, the single dot operator was an ancient mistake which is why so many programming language features are about making it smarter. Properties as mentioned in this article are an ancient way to fake the dot operator into a "field" but actually make method calls. Modern C# also picked up the question dot operator (?.) for safer null traversal and the exclamation dot operator (!. aka the "damnit operator" or "I think I know what I'm doing operator") for even less safe null traversal.