Yes, at this point the choice is who gets to spy on you.

JavaScript: i know it was easy to write it like this but you should index your citations next time

Typescript: I meant properly, not on your scratch sheet

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.

Lies of P got me hooked.

Whenever I see the label “soulslike” I expect a cheap clone that doesn’t understand what made DS special and just superficially copies its mechanics.

I didn’t expect much going in so I was pleasantly surprised by how good it is.

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.

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.

The EU introduced a limitation to how much power electric devices can consume in off or standby mode.

0.5 watt normally, 1 watt if they have a status display and 2-8 watts if they’re connected to a network.

On a yearly basis this saves as much electricity as one of the member states (Romania) used in a year.

My point is that small things add up to huge numbers.

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.

Configuring your bundler properly has to be done once per app, and it can significantly cut down on your app’s size.

People expect to see apps, not web pages, but we can be smart about it. Tree shaking has been around for years now, if you build your app properly your bundle will only include the pieces of code that actually gets referenced, e.g. if you pull in a 2 megabytes large library but only use it for one function, only those few lines from the lib will end up in your bundle.

I find it to be an interesting solution looking for a problem. There could be many applications but I’ve yet to see one that blockchain could solve better than anything else that we already have, outside of crypto currencies.

Web3 is an interesting thought experiment but I don’t see how it would work in real life. It would be extremely slow, data loss would be a daily occurrence and it would be a privacy/security nightmare.

I was working on a hobby project where I used a niche framework in a somewhat uncommon way. I was stuck on a concept that I think the documentation didn’t explain well enough, at least for me, and I couldn’t find any resource on it aside from the docs.

I asked Bing to write a piece of code that does what I wanted and explain each line. It was perfectly working and the explanation was also understandable. All it did was search for its official documentation. It really blew my mind.