The entire studio behind Life by You has been liquidated and everyone in it fired.

Better hope Paralives and InZOI are good, otherwise Sims will be without a competitor for 20 more years.

There are plenty of pasta dishes and sauces that use cream, and while sour cream is not used in italian cuisine I think it tastes amazing :)

So I can absolutely see sour cream working in pasta

I am always amazed by how the japanese are often times very willing to experiment and be inventive in terms of melding their own culinary culture with foreign ones, considering the isolationist and conservative history and reputation they have overall as a people.

To me, that simply says that food really is one of the universal languages.

I’d love to try this dish if just for experimentation, although I suspect it wouldn’t be something I’d have more than once lol

Yeah, no judgement here, when one is poor they gotta do what they gotta do, and ketchup is probably cheaper than decent tomato sauce in some parts of the world I would imagine.

That said, I am willing to bet that the same pasta but with actual prepared tomato sauce (that means put it on the stove, let it simmer, add some salt, maybe a bit of pepper or a pinch of chili flakes if you like, and a drop of EVO oil when it comes off the heat) in place of ketchup would be even better.

Although in your case, the ketchup recipe likely brings back happy emotions relating to your childhood which, after all, are also part of the food experience. Cheers!

+1. Arch is super easy to install, just open the install guide on the wiki and do what it says.

It’s also really stable nowadays, I can’t actually remember the last time something broke.

As a counterpoint, on ubuntu I constantly had weird issues where the system would change something apparently on its own. Like the key repeat resetting every so often (I mean multiple times an hour), weirdness with graphic drivers, and so on.

That said, I also appreciate debian for server usage. Getting security updates only can be desirable for something that should be little more than an appliance. Doing a dist upgrade scares the shit out of me though, while on arch that’s not even close to a concern.

As an italian my strong belief is that your wife should put whatever she wants on pizza. Hell it’s a flatbread with condiments, go crazy. It’s meant for it. If you want a none pizza with left meat, you should have a none pizza with left meat.

Now if you put ketchup on pasta, I will judge your culinary literacy. Ketchup makes for a terrible pasta sauce

What “it” is configurable? If the code is indented with 4 spaces, it is indented with 4 spaces. You can configure your editor to indent with 1 space if you want, but then your code is not going to respect the 4 spaces of indentation used by the rest of the code.

I repeat, the only accessible indentation option is using tabs. This is not an opinion because every other option forces extra painful steps for those with vision issues (including, but not limited to, having to reformat the source files to tabs so they can work on them and then reformat them back to using spaces in order to commit them)

Hard tabs are the only accessible option though. If you care about developers with a different vision capability than yours, the only correct indentation choice is tabs.

If, because of bad vision, someone needs to crank the font size way up, it’s very possible that they might need to work with a tabstop of 3, 2, or even just 1 space.

With tabs, this is user configurable. With spaces it isn’t.

Code example looks wrong? null is passed as updater to a. As far as I understand, what is passed as callback to a is supposed to be the updater instead (especially since the ctor errors on both val and updater being null). Also, would be more clear what the difference and usage of updater and callback are if they were called something like calcVal and onValChanged respectively

We use null objects at work, and as another person said they are a safety feature. Here’s how they work: they are wrappers around another type. They provide the same interface as the wrapped type. They store one global instance of the wrapped type, default initialized, in a memory page marked read-only.

Here’s why they are considered a safety feature (note: most of this is specific to c++).

Suppose you have a collection, and you want to write a function that finds an item in the collection. Find can fail, of course. What do you return in that case? Reasonable options would be a null pointer, or std::nullopt. Having find return a std::optional would be perfect, because that’s the exact use case for it. You either found the item or you did not.

Now, the problem is that in most cases you don’t want to copy the item that was found in the collection when you return it, so you want to return a pointer or a reference. Well, std::optional<T&> is illegal. After all, an optional reference has the same semantics as a pointer, no? This means your find function cannot return an optional, it has to return a pointer with the special sentinel value of nullptr meaning “not found”.

But returning nullptr is dangerous, because if you forget to check the return value and you accidentally dereference it you invoke undefined behavior which in this case will usually crash the program.

Here’s where the null object comes in. You make find just return a reference. If the item is not found, you return a reference to the null object of the relevant type. Because the null object always exists, it’s not UB to access it. And because it is default initialized, trying to get a value from it will just give you the default value for that data member.

Basically it’s a pattern to avoid crashing if tou forget to check for nullptr

I suspect the sarcasm detector of the downvoters might be faulty

Meh. Been developing professionally with C++ for 10 years at this point. I’m one of the weird people that kinda likes C++ and its pragmatism despite all its warts.

I’d like C++ better if it didn’t have inheritance. There are better solutions to model interfaces, and without inheritance people can’t write class hierarchies that are 10 levels deep with a different set of virtual functions overridden (and new virtual functions added) at each level.

And yes, that is not hypothetical. Real codebases in the real world shipping working products do that, and it’s about as nice as you can imagine.

You do have a terminology mismatch. In C++, an abstract class is a class with at least one pure virtual method.

Such classes cannot be instantiated, so they are useful only as base classes.

An interface is more of a concept than a thing.

Sure you can say that Iterable is an interface that provides the Next() and Prev() methods and you can say that Array is an Iterable because it inherits from Iterable (and then you override those methods to do the correct thing), and that’s one way to implement an interface in C++.

But you can also say that Iterable<T> is a class template that provides a Next() and Prev() methods that call the methods of the same name on the type that they wrap (CRTP aka static polymorphism).

Or you can say that an algorithm that scans a collection T forward requires the collection to have a Next() method by calling Next() on it.

And I can think of at least 2 other ways to define an interface that isn’t using abstract classes.

And even if using abstract classes, inheriting from them is definitely the least flexible way to use them to define an interface, because it doesn’t allow one to do something like mocking functionality in tests, because it’s not possible to redefine the class to be tested to inherit from the test interface implementation with mocked functionality, so one still needs something to the effect of dependency injection anyway.

So yeah, abstract class is very different from inheritance, and it’s also very different from interface, even though it relates to both.

Looks to me like the ruling is saying that the output of a model trained on copyrighted data is not copyrighted in itself.

By that logic, if I train a model on marvel movies and get something that is exactly the same as an existing movie, that output is not copyrighted.

It’s a stretch, for sure, and the judge did say that he didn’t consider the output to be similar enough to the source copyrighted material, but it’s unclear what “close enough” is.

What if my model is trained on star wars and outputs a story that is novel, with different characters with different voices. That’s not copyrighted then, despite the model being trained exclusively on copyrighted data?

Copyleft licenses are explicitly leveraging copyright laws.

So if the output of an “AI” is not subject to copyright, and the input material is also not subject to copyright, I can train a model so it outputs a byte-for-byte copy of, say, a marvel movie, and said copy is copyright free, yes?

Maybe Eidos would love to get another Deus Ex out there but there’s no publisher interest

You know, they could just… Say this, and placate everyone. I’m honestly sick and tired of companies in general, and game companies specifically, being afforded this stupid level of opaqueness.

If you were to talk to someone that would exclusively stonewall you, you’d be quick to stop talking to this person. When it’s game companies though, everyone bends over backwards to try to find justifications for their behavior on their behalf.

TAA has become so common because its’s “free”. Temporal data is required by DLSS and FSR, so if you are implementing those technologies you already have the necessary data to implement TAA, making it a no brainier to include.

Not so fast now! High resolution video only available on edge on windows

I don’t know how to help you directly, but you could write a script that turns vibration on, then sleeps for an appropriate amount of time, and loops indefinitely. This way even if vibration stops after a few seconds, the script will turn it back on immediately.

As for vibration strength, I have no clue. SDL has controller APIs, maybe it’s able to control vibration intensity. In which case, one could write a CLI SDL-based program for this.

If this was cpp, clang-tidy would tell you “do not use else after return”

I don’t know how null works in swift, but assuming it coerces to bool I’d write

if (a) return a;
return b;