I think they were referring to the recent events in Israel in this case but the instance was problematic from the start.

I’m usually fine with interacting with people from all over the political spectrum, but genocide is way over the red line for me.

The amount of heavily upvoted comments there about white washing genocide, trying to deny it or somehow justify it was disgusting. I’m not talking about recent events but mostly those committed by regimes that called themselves communist, no matter how far they actually were from it.

I don’t agree with communists in general but I also don’t agree with many other ideologies. I don’t mind being around communists if we can talk respectfully. But I consider tankies the left wing version of neonazies.

Finally

Depends on what you already know.

Functional languages like Haskell, Clojure or Erlang have a reputation of being hard to grasp.

Rust’s borrow mechanics are hard for some people at first, especially because it’s very unique to the language.

Javascript can be frustrating because it also has some rare features among popular languages, and uses the same keywords for different concepts. It’s not bad at all once you let go of your assumptions and dedicate the time to understand how it works under the hood.

C++ is also notorious for being hard but I haven’t used it for a very long time so I can’t say anything about it.

Probably Typescript, it has so many quality of life features that I miss when I’m using anything else. A close second is C#, Kotlin third.

Rust when performance really matters.

PowerShell when scripting and automating stuff. It’s common to hate it because “microsoft bad” but it’s very logical and it feels modern. Funnily enough, I’ve only used it on Mac and Linux.

I wonder how Svelte’s code is built to make this tradeoff worth it. I’ve been using TS for a long time and in every project the compilation part was the shortest task in the whole build process, especially when you compare it with bundling or running unit tests.

The title makes it seem like it’s a wide spread thing in the industry but according to the video it’s 3 frameworks.

Yeah, it’s additional work but I’ve found that really convoluted or complex type definitions usually mean you should consider refactoring. Of course this is a bit different when it comes to developing frameworks where you might want to support a bunch of different use cases.

Maybe I’m biased because I’ve been using TS ever since it first came out.

I used it on a Mac and on Windows, for me it feels very modern when compared to bash (although I never was a bash expert).

However, the problem is that it’s not installed by default on Linux (at least on most distros as far as I know) and Mac, and Windows machines might have an outdated version which you’ll have to take into account.

So unfortunately it doesn’t meet OP’s criteria that it should “just work” without installing an interpreter.

Countries that aren’t federations will also take this seriously.

Yeah but javascript has 473 popular frameworks and counting, and the churn is immense. Your codebase becomes out of date before you’ve finished writing it.

That’s not really the case anymore, it was back at around 2015 for a few years when nodejs blew up and we realized that JS is capable of much more than we initially thought.

We threw a thousand different things to the wall and a few frameworks stuck. Today the ecosystem is pretty stable, especially of you choose a popular framework like React or Angular.

Writing self documenting code reduces the need for comments significantly, but you’ll still need to write docs and even code comments when needed.

I had a lead architect at one of my previous workplaces who outright forbid writing comments, otherwise the build would fail. That lead to convoluted and slow solutions in order to make the code readable, or just parts that nobody wanted to touch because nobody understood them.

My point is that you should strive towards self documenting code as much as it makes sense, but don’t take it to mean that you should never write comments.

People should be able to tell what your code does without going deep into implementation details but that’s not always possible, especially if you’re working with lower level languages with fewer abstractions, or projects with complex algorithms or architecture.

Thanks for adding these UIs as an alternative. Especially m.lemmy.world, it feels like a native app.