Can you explain more on this one? Is this position against lookup or read-only db tables?

It as in LLMs or it as in intellisense?

Mine is basic since I'm still a noob programmer, but if you are on an OS with APT or something similar, you should absolutely automate all your commands for updating your software packages by consolidating everything into a single script.

It's easy to create a bash script that runs all your needed commands sequentially, so why not? Hell, I take it a step further with my script by aliasing it to 2 letters since I don't wanna type the full script name or type tab to autocomplete it.

Tab chars are better, no opinion on the width but if you use the chars, everyone can do what they want

I just use Linux mint which does all this for me out of the box

They are stupid, their competitors offer far better services

I don’t think anything needs cloudflare in front of it. It’s a worthless service.

It was a simplified example.

B and C can’t share any other attributes without duplication of code

struct A {
    [[nodiscard]] virtual std::uint32_t DoSomething() = 0;
};

struct B : A {
    std::uint32_t DoSomething() override { 
        return 0;
    }
};

int main() {
    B b;
    b.DoSomething(); //no warning
}

even if you use virtual attributes aren't inherited.

If you ment members instead of attributes this is unrelated to virtual:

struct A {
    std::uint32_t a;
};


struct B : A {
    void DoSomething() { 
        std::println("B"); 
    }
};

struct C : A {
    void DoSomething() { 
        std::println("C"); 
    }
};

Now the member is shared and it works fine and there is no virtual.

There’s also no strict enforcement of inheritance.

True, but neither is there when just using virtual:

struct A {
    virtual void DoSomething() = 0;
};

struct B : A {

};

This compiles fine if final is not added.

Not that its an issue as reflection has solved this problem:

consteval std::string_view HasMethods(std::meta::info impl, std::meta::info iface) {
    constexpr auto ctx = std::meta::access_context::unchecked();
    for (auto fn : members_of(iface, ctx)) {
        if (!is_function(fn) || is_special_member_function(fn)) continue;
        bool found = false;
        for (auto cand : members_of(impl, ctx))
            if (is_function(cand) && has_identifier(cand) && identifier_of(cand) == identifier_of(fn) && type_of(cand) == type_of(fn))
                found = true;
        if (!found)
            return std::define_static_string(std::string(identifier_of(impl)) + " is missing " + display_string_of(fn));
    }
    return {};
}


struct A {
    void DoSomething();
};

struct B  {

};
static_assert(HasMethods(^^B, ^^A).empty(), HasMethods(^^B, ^^A));

// g++ -std=c++26 -freflection main.cpp
// main.cpp:30:41: error: static assertion failed: B is missing void A::DoSomething()
// 30 | static_assert(HasMethods(^^B, ^^A).empty(), HasMethods(^^B, ^^A));

Now you get the strict enforcement of inheritance and no virtual.

tbf useEffect is what fried even cloudflare a while back, oh and also me many times. Insanely easy to write once. Just as easy to forget a dependency or modify the function into creating an infinite loop. Or hell using useEffect(() => {}) i.e. an anonymous function instead of naming it so I have to read 30 LoC to figure out what it does only to realize it's not even the effect I needed -.-

Yep. IRC at work would be just fine.

Exactly this. Instead of learning about the complexity and footguns of working directly on the DOM, people get to learn about the complexity and footguns of manipulating the virtual DOM.

React isn't bad, but it was designed in a very opinionated way to build certain kinds of apps. Excessive abuse of React hooks shows a common desire path to build things that don't require that framework. Most people basically just want signal based reactivity but don't know that it exists.

LOL. That mess is somehow better?

One utility function somewhere vs runtime polymorphism everywhere?

Yes.

Firefox is a good browser

Also, if they can detect mistakes, they should be able to FIX them instead of adding extra busywork on my table.

I hate this trope that languages should “learn” from each other. Because this typically means “should copy features / syntax”.

If I want to use Perl, I use Perl. I don’t need Perl in Rust, then I wouldn’t need Rust anymore.

You just reinvented polymorphism with extra jank.

Sublime Text does. Even unsaved buffers.

Charlieeeeeee!

It's pretty useful for text editing, but for any more serious code work I prefer to use an actual IDE.

As far as software development, Vim seems to me like an excellent solution for an irrelevant problem (typing speed).

Also, it's great that it's lightweight, but I bought the entire RAM and I'm going to use the entire RAM :P

although, to your credit, Microsoft in no way makes their intended use obvious or intuitive

Which is stupid.

Trillion dollar corporation, btw

I also like to use an alias to update like the previous comment described. I did it on Mint, and I still do it now on Debian even though it has a graphical update manager too.

I like it better this way, probably for readability when there are multiple updates, and definitely for the verbose progress indications. I do already use the terminal all the time too.

My alias does something like apt update, apt upgrade, flatpak update, and then a commented-out firmware manager update.

It is though

How is it jank to put one utility function in a file somewhere you never need to look at again?

That is if you even want to do the assert since if the type doesn't have the method it won't compile in the calling function anyway but since you mentioned the strict check it's fully possible.

And why isn't it jank to write virtual, final, and override everywhere and have the entire codebase infested with vtables.

• C++ is an awful language overall.

• Linus is just some guy with good programming skills and not an authority over anything tech.

• There aren't any good text editors in the wild. VSCode is awful apart from extension support. Kate is close to being perfect but lack of extensions are pulling it back. Vim, Helix, Emacs, NeoVim are all flex toys.
  nvm just tried zed with AI disabled

• AI bad

Since it's apparent you can spot what tutorials do it wrong, would you be able to provide links or references to online tutorials that get it right?

One of the most valuable things you can do if you know a technology well enough to have these gripes is not just to condemn people fucking it up but shine a light on people that are trying to do it well.

No single letter variable names.
Yes I also mean the i in for loops you see in tutorials. Write out "index" or give it a more descriptive name. Doing the typing isn't the hard part of programming, nor the most time consuming, so making it take a teeny tiny bit longer by having longer variable names is more than worth the value of variables the effortlessly describe themselves.

line length is not that big of a problem anymore, we're not on CRTs, people are regularly developing with 4k monitors, we don't need to limit to 40 character lines but even still if you can't possibly think of a way to break up that long of a line and the only thing you can think of to make it shorter is using over-acronymized variable names then you've already lost the plot somewhere

Printers and fax machines are completely outmoded and should be removed from every environment.

Want to know something horrendous? Odin, my current favorite language, recommends mixing tabs and spaces in their style guide.

What's worse, their justification actually makes sense.

My distro doesn't have any OOTB tools AFAIK that does this, which is why I "need" my script and alias. That is one advantage of mint, though. Closest I have is KDE discover, but IDK how it fully works for/with updates.

Java is overall a good language for getting things done, although not enjoyable to work with (thank god we have Clojure)

CachyOS and MX Linux both do this out of the box too

I disagree when it comes to standardized single-letter variable names. They're invaluable when writing dense code for games or other math-heavy applications and you learn to recognize them very quickly.

So i for index in loops (and j, k for nested loops, but you're almost always doing something wrong if you need them); x, y, z for position and h, w for size; r, g, b, a for color data, etc - you'll immediately know what the variable is for at a glance even though it's a single character.

Another benefit is that having related variables be the same character width keeps code visually aligned, which helps with readability.

React is absolute trash and people should stop using it

I agree. Short, nonsensical, meaningless, artificial variable names make me think the person writing the code is a dinosaur from when they still had punch cards. Get with the times.

Upvoting because I disagree with every word of what you wrote.

Agree with half of that. C++ is last century stuff and should be replaced. Any new code in C and C++ is immediately a vulnerability.

Fuck... They are right. This makes a lot of sense.

Now I have to share this with everyone at work.

People in FOSS community (including users) nitpick way too much about eachother's ethics and are mostly dictators so they expect everybody's views to align with themselves and each sub-community/individual see themselves as the source of moral balance.

"oh no one of project XYZ maintainers doesn't like trans people we should boycott the project and fork it into LibreLGBTQXYZ"

be professional ffs. See the project as the software and it's technicality, art, science and engineering. we can't be too picky about individual people's beliefs and ethics especially in current situations.

People (such as myself) make the argument that it does a better job because it's focused more on reading code than writing it since you don't start in the "write" mode like in most editors.

I would say the choice of text editor shouldn't make a difference in productivity so long as it doesn't actively get in your way too often (looking at you, poorly implemented autopairs) and it supports the relevant LSP and debugging protocols.

Disagree. Linters catch common logic errors, formatters remove nearly all discussions about formatting style. I remember MRs being held up for days at work because of formatting discussions, being resolved by a "style guide" that couldn't be memorised, and being followed by new discussions about formatting that held MRs.

The that epitomises this is the nixpkgs repo. There are thousands of PRs stuck in nitpick hell because some particular reviewer wants commas here and another wants them there.

Use a syntax-aware editor that formats code the way you like it. Save it any goddamn way that is syntactically valid. Anyone else who opens it will see it any way the like in their own syntax-aware editor.

So every MR restyles the code to fit your style? How are you going to review the code?

That's the point lol

We are waiting for you take over the X11 project.

Atleast C is easy to understand which makes it easier to find and fix vulnerabilities. C++ feels like it's duct tape holding it together.

Isn't that Python's whole paradigm?

"I will happily promote the project of a person who openly says people like me should be shot. What's the problem?"

...which is why I love #[rustfmt::skip] so much! You can do stuff like

#[rustfmt::skip]
const DIRECTIONS: [[i8; 2]; 4] = [
             [0, 1],
    [-1, 0],          [1, 0],
             [0, -1],
]

while still enjoying the convenience of auto formatting elsewhere.

Although linters which act on the behavior of code are unequivocally a good thing, e.g. "hey, this comparison will always return false you probably made a mistake here".

We're going back to server-side rendering.