There are use cases. Like containers where the pointer to the object itself is the key (for example a set). But they are niche and should be implemented by the standard library anyway. One of the things I hate most about Java is .equals() on strings. 99.999% of times you compare strings, you want to compare the contents, yet there is a reserved operator to do the wrong comparison.

The theme is at https://github.com/Calcoph/tetheme. at themes/TeTheme_red-color-theme.json. The other is an old one that is almost the same as default vscode dark.

I don’t like this article. The only 2 options considered are:

• One color for each different token equally spaced by hue + colorized brackets.
• Almost no coloring at all.

There is a huge range of options in between.

I use my own theme because I dislike every theme I’ve tried so far.

It is basically all browny orange (because it is easy on the eyes) on a #000000 black background. However, each token type has a distinct color (within the same hue). This makes it easy to read since there is no constant color switching. But it’s also very easy to see which type a token is, since the colors are distinct enough. Obviously no colored brackets.

And I still have room for highlighting special tokens that I care about. For example self/this is dim pistachio green instead of orange. String literals are greeny yellow and numerical constants bright orange. And punctuation is dark green.

It also not only doesn’t colorize variables as the article suggests, it colorizes them with semantic highlighting. Parameters, and local variables are different colors. They also differ if they are mutable (for rust for example). Which means at least 4 different colors just for variables. And it helps a lot.

I also dislike that the article dismisses the main purpose of colorizing keywords, which is typos. Colors allow to see typos as you write them. Having a section of code and saying “find me the typo” is not a realistic scenario. As you type “return”, you expect that it is red whole writing, and blue when you type the last “n”. If it doesn’t turn blue when you finish writing it, you know you didn’t do what you wanted to do. Which is instant feedback. This goes for all tokens, not just keywords. If I write the name of a struct, but it has the color of a variable, I probably wrote it wrong or I need to import it.

The difference between treason and a revolution is which side wins at the end.

Just make sure you’re enough people doing it.

Encapsulation.

Any time i even think I need inheritance, I immediately change it for encapsulation. I’ve never regretted this.

Yes that is correct. A BigInt represents the entire integer set.

Rational numbers are defined by just 2 integers. Therefore, 2 BigInts represent the entire rational set.

Yes. Have a structure with 2 BigInts. Treat one as the numerator. The other as denominators.

It might not be efficient or fast. But it is possible.

In C, goto is basically a necessity though. There is really no good way of error handling.

Options:

1. Using goto

void func(void *var) {
    void * var2 = malloc();
    if var == Null {
        goto err;
    }

    do_something();

err:
    free(var2);
}

2. Early returns:

void func(void *var) {
    void * var2 = malloc();
    if var == Null {
        free(var2);
        return;
    }

    do_something();

    free(var2);
}

3. Skipping with conditionals:

void func(void *var) {
    bool error = false;
    void * var2 = malloc();
    if var == Null {
        error = true;
    }

    if !error {
        do_domething()
    }

    free(var2);
}

4. Early return + cleanup function.

void cleanup(void *var2) {
    free(var2);
}

void func(void *var) {
    void * var2 = malloc();
    if var == Null {
        cleanup(var2);
        return;
    }

    cleanup(var2);
}

Option 1 is really the only reasonable option for large enough codebases.

Option 2 is bad because duplicate code means you might change the cleanup in one code path but not some other. Also duplicate code takes up too much valuable screen space.

Option 3 has a runtime cost. It has double the amount of conditionals per error point. It also adds one level of indentation per error point.

Option 4 is same as option 2 but you edit all error paths in one single place. However, this comes at the cost of having to write 2 functions instead of 1 for every function that can error. And you can still mess up and return while forgetting to call the cleanup function.

You must also consider that erroring functions are contagious, just like async ones. I’d say most of the time a function is propagated upwards, with very few being handled just as it ocurrs. This means that whichever downside your option has, you’ll have to deal with it in the whole call stack.

Does Canada have a road paint shortage? How is that a crosswalk? It’s barely 2 thin lines! Paint the damn thing so it is clearly visible. I would be scared trying to cross one of those.

EDIT: For the people without reading comprehension: I’m not justifying the dude in any way. Just commenting on the awful crossing marks.

In the movies extended version you can see saruman clearly dying after the ENT counter-attack. So in the movies, only sauron is left at this point.

I don’t think anyone denies that whatever happens after you no longer pass your genes around has no evolutionary effect.

Whether helping your offspring is evolutionarily helpful or not might be debatable (I don’t see how it would not be helpful though)

Even in beings that not form societies it has an impact. Example:

You reproduce, then instantly die. Now your offspring have more available resources around them, since you no longer consume them

Or, your reproduce and you become much stronger, but not aggressive towards non-predators. Now predators are less likely to be near you, and your offspring are probably near you. Therefore, they probably benefit from having less predators around.

You’re not stupid for it. Since it makes sense.

However, due to the way we “calculate” the sizes of infinite sets, you are wrong.

Even integers and all integers are the same infinity.

But reals are “bigger” than integers.

Show one use case of Blockchain outside cryptocurrency. It must also be a better solution than a traditional database.

Why digital ID? Can’t they just make a physical ID like every country?

If there’s literally a bike lane along the road, there’s no reason to use the road on a bike unless you’re an asshole.

I do pay the water company, which doesn’t give me the right to throw wet wipes down the toilet.

I do pay a waste management tax. That doesn’t give me the right to throw dogshit in the paper container.

We all pay to build bike lanes. Since people using bike lanes helps both cyclists and drivers. Just use the damn bike lane if there is one.

No, that’s doing it in an orderly fashion. You meant of-by-one

The good thing about the raspberry pi is that it costed less than 30€. At 200 it’s no longer a tinkerer toy.

If you don’t understand the “problem” part in the “what problem does this tool fix?” Then you probably don’t need that tool. You should probably try the program they mentioned that didn’t fix their specific problem. Since that program probably has way more users and a more entry-level documentation.

Bash might be better than IE. But I think we can agree that it is no longer a good shell.

Its syntax is awful, and lacks many features that other shells have.

It is only so widely used because it is a de facto standard. If bash was created today, barely no one would us it.

For me it’s the opposite. Lossy ones (the ones that seem to maintain quality while lowering size by a lot) are magic to me but lossless is understandable.

What do you mean “treat this image as a wave and do an inverse Fourier transform on it in order to discard the high frequency low amplitude noise”. wtf? Straight up magic.