Exactly. That’s why I buy Nintendo games near release and am patient for PC games.

Why post the same image twice?

Poetry/uv is similar to Rust’s cargo. You specify your direct dependencies in a TOML file and their version constraints and the tool takes care of the rest.

My understanding is that it’s necessary given the current design of the compiler. That doesn’t mean it can’t be removed at some point.

It would be really nice to be able to define trait impls wherever, and it should be possible.

Don’t worry, new research shows all the negatives are made up by big water. You may continue consuming as many <sponsored energy drink> cans as you want. Drink verification can to confirm.

And there’s nothing wrong with that

Agreed, it’s just nice to know that going in to a massive article like this. Are these reasonable complaints, or are they just justifying a new project for themselves?

mlua looks nice. It also does async for coroutines, which is really nice.

There are a ton of options, depending on what you have. In essence, a file server is really simple, you just need a computer with network access with sufficient storage. Here are options, from simplest to fanciest:

1. drive plugged into your router - simplest and most ghetto
2. drive that supports network access - slightly less ghetto
3. buy a NAS - more money and less freedom, but much simpler than DIY
4. old computer (laptop, Raspberry Pi, etc) that you have laying around with something like TrueNAS, NAS4Free or OpenMediaVault running on it
5. 4, but with a general purpose OS on it (Debian, Fedora, etc) running some kind of file hosting software (samba, Nextcloud, Seafile, OpenCloud, etc)
6. 4 or 5, but with new hardware

The costs can vary from free to thousands of dollars, depending on storage and compute needs and how far down the fancy scale you go (note: 3 is more expensive than 4, and comparable to 5).

Everything is running and I’m not making many changes because work got hectic. I have a few projects I’d like to tackle once I get time:

• finish migrating to podman
• get a new drive to test migrating to microos
• get more media to finally eliminate Netflix (SO is still clinging to a few shows)
• find a smaller box for my NAS - currently in a massive ATX box, but I don’t want to pay an arm and a leg just for space savings

Here are my reasons:

• no Linux support - Heroic works, why doesn’t Epic do what GOG do and revenue share w/ Heroic?
• exclusivity deals, which reduces options outside of EGS
• Epic’s anticheat works on Linux, but their own games that use it don’t, that’s a pretty big slap in the face

I certainly want more competition to Steam, but that competition needs to do something other than exist for me to use it. GOG is that, and if they properly supported Linux, they’d get most of my gaming money. But they don’t, so they only get some of it.

Yeah, this probably reads like a Linux fanboy post or something, but I’ve been using Linux longer than Steam supported it with its client, and I’ll still be here if Steam leaves. It’s my platform of choice, and a vendor needs to meet me here if they want my business. Valve did, so they get my money. I honestly don’t need much, I just need games to work properly on my system.

a way to track them

Yes, that’s what I’m suggesting. Injecting some kind of metadata that gets stripped at code gen time would probably work.

worse incremental compilation performance

Would it really be that significant?

without allocating everything on the heap

I’m talking about compile time.

Start with all of the known safe cases (basic types should be fine), then move on to more dubious options (anything that supports iteration). Then allow iterable types but don’t allow iterating over a mutable reference. And so on. If it’s a priority to loosen up the rules without sacrificing safety, surely some solutions could be found to improve ergonomics.

Or perhaps there could be some annotations to make a reference as “unsafe” or similar instead of just a block. If something is safe in practice but not verifiably safe, there should be a way to communicate that.

You want some annotations to break out of the safe subset of the language

The annotations would indicate that something unsafe is going on, so it’s like an unsafe block, but on a reference. That way it’s clear that it’s not being checked by the borrow checker, but the rest of the application can be checked.

I really liked the idea of an optional, built-in GC w/ pre-1.0 Rust where specific references could be GC’d. If that were a thing in modern Rust (and the GC would only be enabled if there’s a GC’d reference included), we could get a lot more ergonomics around things like linked lists.

I guess. Our use case was a bit different in that it carried which features they had access to, not just that they had some access. You could probably do that with a JWT as well, but we just issued them an encrypted upgrade file that matched the serial of their device and granted all usersln that device access to the feature.

That was simple enough for us.

OP wants to build a game. When I build games, I start high level (Python, Lua, GDScript, etc), then move the slow, stable bits to something faster. That’s a really effective flow, and at the end, I get a great scripting interface for my game.

But then, given the complaints, I’m not actually sure they do want to build a game, I think they really want to build a language, and maybe an engine.

I think all three are great.

the orphan rule is not worse than what other languages allow

Sure, but that doesn’t mean it can’t be better.

Surely the compiler could delay optimizations until the entire project is built, no? Then it knows what implementations exist, and the developer could then decide how to deal with that. Perhaps the dev could decorate the trait impl as overriding all others, overriding one specific impl, etc.

The orphan rule feels like throwing the baby out with the bathwater.

You can still trivially violate memory safety without multithreading or concurrency

Sure, and ideally those cases would be accounted for, or at the very least the dev could annotate each use to turn the borrow checker off for each instance, and that could print something at build time and a linter could flag over it. Unsafe blocks aren’t feasible for everything here.

A lot of these situations are fine in practice. Give devs the ability to sidestep the rules and take responsibility for the outcome.

My brother is an accountant and uses sheets for a lot of non-work stuff, and specialized software for most business needs. He also uses Excel, sure, but there are substitutes for Excel in a lot of cases.

The twin towers made a ton of sense:

• lots of people in a small area
• symbol of America’s dominance of trade
• iconic buildings in the heart of perhaps the most iconic American city

Except second hand. That’s my point.

I’m not Brazilian, but I’m guessing importing stuff is expensive. Look at PC components elsewhere in the world, it’s typically much more expensive than the US.

Here’s my investment portfolio:

• 70% US - I still think US will outperform, but I’m not as confident anymore; mostly VTI with a small cap tilt using DFSV
• 30% international - mostly VXUS, with a small cap tilt using DISV

I think US stocks will take a beating during Trump’s presidency, provided he keeps messing with tariffs, but I think longer term the US will bounce back because we have a very attractive regulatory environment for businesses.