Lol that’s what I noticed too.

One side wants less people to die, the other side wants fascism and racism. Please help me compromise.

So are you saying that me pushing a pregnant woman down the stairs is the same as doing so to a non pregnant woman?

Imo, no. Pushing a woman is assault, pushing a pregnant woman is assault and something else (another post suggested something akin to manslaughter, which I think fits if the assault causes a miscarriage)

the pro-life response is simply that the unborn child doesn’t get a say in the matter.

Correct. An unborn child doesn’t get a say in whether they are aborted or born. They have no opinions, they have no wants. The unborn child cannot consent to being aborted but they cannot consent to being born either. The only valid opinion and choice is that of the mother, because it’s the mother’s life that is very physically (and eventually also mentally, socially, etc) affected by the pregnancy.

Which is also why I said that pushing a pregnant woman should have harsher penalties than just assault: it also endangers or destroys something whose state of being only the woman should be in charge of.

It’s like if I pickpocket your wallet that’s stealing, but if I steal the wallet from your house that’s also breaking and entering.

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