It’s a horn. No veins https://m.youtube.com/watch?v=m4_9TFeMfJE

Installing dependencies via the OS’ package manager is one of the worst experiences there is. I understand it for C, because the language is ancient and doesn’t have its own dependency manager.

But when developing, there are many dependencies you need that aren’t in the package manager. And when they are, they are often years old versions.

And in the case of python, it installs dependencies in the global scope, which means that you sometimes import that version instead of the pip one.

And in the case of python there’s the extra:

python main.py

python command not found

Ah. It must be python3 then. Now all the bash scripts are broken. Since it’s python3, I’m going to install packages with pip3:

pip3 install matplotlib

pip3 command not found

What?? So for python you need to put the 3, but for pip they removed it?

Ngl, python development is much less stressful on windows.

The same argument for cartels. “We didn’t all increase our prices to the exact same amount, we just paid a consulting company to tell us which price we should use. Of course our competitors used the exact same company, but that’s just a coincidence”.

Tbf that leads to the problem of:

Company/Individual makes program that is in no way meant for making management decision.

Someone else comes and deploys that program to make management decisions.

The ones that made that program couldn’t stop the ones that deployed it from deploying it.

Even if the maker aimed to make a decision-making program, and marketed it as so. Whoever deployed it is ultimately the responsible for it. As long as the maker doesn’t fake tests or certifications of course, I’m sure that would violate many laws.

Gen AI porn and shitposts are the only 2 decent use cases I’ve seen of gen AI.

You can’t make half of those without training it on porn.

Maybe they changed the defaults. I stopped using GitHub after they trained their AI over private repos.

But I remember clearly that I was annoyed when looking at my own repos because my forks (for actually doing PRs) would show at the top instead of my own repos.

Maybe some people don’t delete the fork after their PR is done.

In my case, I found another explanation.

Sometimes, a random person comes and forks one of my repos. I check their profile, and it’s a techbro student with hundreds of forked repos without any commits. With their bio referencing AI or some shit.

I’m pretty sure these people fork a lot of repos just to pad their CV or something. Make it look like you have a lot of repos. Because when you go to someone’s profile, it is not clear that a repo is a fork instead of their own creation.

Maybe naming single-letter variables I can see being easier to review than to do.

Any other kind of refactoring though, IDE refactoring tools are instantaneous and deterministic.

The problem with that is that reviewing takes time. Valuable maintainer time.

Curl faced this issue. Hundreds of AI slop “security vulnerabilities” were submitted to curl. Since they are security vulnerabilities, they can’t just ignore them, they had to read every one of them, only to find out they weren’t real. Wasting a bunch of time.

Most of the slop was basically people typing into chatgpt “find me a security vulnerability of a project that has a bounty for finding one” and just copy-pasting whatever it said in a bug report.

With simple MRs at least you can just ignore the AI ones an priorize the human ones if you don’t have enough time. But that will just lead to AI slop not being marked as such in order to skip the low-prio AI queue.

I hope they are prepare for the AI slop DDoS. Curl wasn’t, and they didn’t even state they would welcome AI contributions.

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.

I haven’t tried using a GUI library for this. But it is possible (and relatively easy) to build for Android using rust.

I found this tool called “x build” that works basically out of the box. It was a bit tricky to set up the release build, but got it working too.

I made a small App using winit+wgpu and it seems to work. Win it also has touchscreen-specific events.

Iced does use winit+wgpu, so if they are listening to the touchscreen events, it should work for Android. Haven’t tested it though.

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.

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