And when people started writing books instead of memorizing epic poems.

And just about 5 of them have the same capacity as an iPhone battery. Absolutely insane.

Python caches bytecode, so the translation happens only once.

Java loads everything immediately and keeps it in memory. All beans, all connections, etc. That takes up a ton of memory.

Of course, but I’m not productive in it.

If I have to do everything myself, it will take more time to get it done. The trade-off is of course always control/speed vs convenience, but C is definitely too inconvenient for me.

Not that limited. Limited means an old thin client, not a microcontroller. I already set up a small web server on a pi pico with mpy, so it’s quite impressive. But from what I understand, the interop with “MacroPython” is not that great.

Did you use mpy for x86 devices? Are the limitations worth it?

But that would mean either using Graal/native image or going full Scala, right?

I only used Scala for Gatling, where it’s obviously very java-y.

There’s nothing to really grow. It’s mostly just small helpers. Aggregate sensor data, pull data from A and push it to B every hour, a small dashboard, etc.

C is too involved for my case , I want to be productive after all.

Rust is already rather low level, though there are some cool looking frameworks.

The long-term goal is for Rust to overtake C in the kernel (from what I understand

Your understanding wrong. Rust is limited to some very specific niches within the kernel and will likely not spread out anytime soon.

critical code gets left untouched (a lot of the time) because no one wants to be the one that breaks shit

The entire kernel is “critical”. The entire kernel runs - kind of by definition - in kernel space. Every bug there has the potential for privilege escalation or faults - theoretically even hardware damage. So following your advice, nobody should every touch the kernel at all.

Germany has a Sovereign Tech Fund for exactly this, and while it’s not perfect, it’s one of the better uses of my tax euros.

Replacing C with Rust in the upstream kernel is akin to replacing the engine in a car while it’s running or being used every day.

That’s in no way what’s been proposed. Rust is used in a very well defined niche, nobody wants to get rid of C.

But it’s just that sentiment that got us here, you’re arguing against a non-existent threat, and thus reject the whole proposal.

And it’s a bad argument anyway. You’re only good at memory management until the first bug takes down production.

Rust isn’t a panacea and certainly has problems, but eliminating an entire class of potentially very dangerous bugs is a very good argument.

The older generations kept leaking contaminated water (reactor coolant), many harbors simply refused entry because they didn’t know the risks involved, and I’m pretty sure the decommissioning isn’t clear either. The way current laws are set up, it’s quite possible that these things go through a few hands and end up on a beach in some underdeveloped country and get dismantled like any other ship under horrible working conditions - but now with the added benefit of nuclear contamination.

No, I’d argue you simply didn’t want to invest in the other tools.

Think about it, you probably spent hours on customizing and automating vim, and then say you’re faster in that. Well, that’s called a habit.

IDE are objectively more powerful and since you can actually see options and navigate quickly, you don’t need to memorize every obscure feature.

All the terminal editor enthusiasts are actively holding us back, because they insist everything outside vim is garbage for enterprise and kiddies.

If your tool of choice is actively hostile to new users for no reason other than “that’s how it’s always been, and thus it’s better”, well then you’re digging a moat to automate your gatekeeping.

I understand it very well. And that’s exactly why I’m writing this.

Ok, I can see you have no idea what you’re talking about.

Then say, grandmaster delusion, what purpose does vim serve, where it is actually the best tool? Writing code? Hardly, it’s way too limited and requires a ton of upfront investment and headspace. Writing config files? Hardly, because if you write these by hand, you’re living in the 90s, that’s what Ansible, Terraform etc are for.

You just don’t want to admit, that vim is nothing more than a habit. Muscle memory.

You’re using the terminal, because you’re used to it. It is not the better tool, it’s simply what you happen to know already.

People who argue with productivity because of some key bindings live in the world of the 80s. You don’t just sit there and type code 12h a day, that’s not how modern software development works.

And all those blockheads down voting me are caught up in their weird superiority complex. They are the powerful superhackers, and don’t understand that we are just highly qualified plumbers.

…so your infrastructure is outdated.

And how often does that happen in the real world?

VIM may have been a very useful tool 20 or 30 years ago, but today it’s nothing else but a tool for one’s sense of superiority. It’s the vinyl of editors.

If you have to type that much code in a terminal, your infrastructure is outdated. Simple as that.

Of course it is like that. You’re saying that the complaint is wrong because the author doesn’t know the history, and now you accuse me of not understanding you, because I pointed this out.

If you have to accuse everyone of “not understanding”, maybe you’re the one who doesn’t understand.

It’s easy to criticize something when you don’t understand the needs and constraints that led to it.

And that assumption is exactly what led us to the current situation.

It doesn’t matter, why the present is garbage, it’s garbage and we should address that. Statements like this are the engineering equivalent of “it is what it is shrug emoji”.

Take a step back and look at the pile of overengineered yet underthought, inefficient, insecure and complicated crap that we call the modern web. And it’s not only the browser, but also the backend stack.

Think about how many indirections and half-baked abstraction layers are between your code and what actually gets executed.

Most names are essentially just landmarks of some sort.

Hamburg is derived from Hammer Burg, simply meaning hammer castle.

Part of Hamburg is Altona, which is lower German for all too near, because it’s really close to Hamburg.

East of Hamburg is Lübeck, which is means “settlement of the lub”, whoever the lub were.

Even farther east is Warnemünde, which is located at the mouth (Mund) of the river Warnow.

Said river is getting pretty wide a bit upstream, which gave the city of Rostock its name (“where the river gets wider”).

East of that: Stralsund. It’s the sound (the water kind) of Strela.

And so on and so on.