What are you doing with Python that somehow this would help at all?

I am really curious, specially given there are many other languages out there to move to vs js.

However you put it, tooling support is way, way better for C and C++ for obvious reasons.

Other critical bits for commercial development in many industries (certs, standards, third-party support, official bindings...) are also completely lacking.

That is not something against Rust, it is just what happens until things get popular enough.

Absolutely. All I’m saying is that it’s non-zero, not that it’s equivalent.

They say can call though, so they are correct: if you can call then you are in an unsafe context.

Yes...? But they're responding to a point about safe Rust. See my other comment: https://news.ycombinator.com/item?id=24028359

If you are really performance concerned, you wouldn't use Python to begin with.

That said, there are many use cases where performance does not matter as long as it is not "too much", for different values of "too much" depending on context.

Assembly code making poor choices can be outperformed by Python code making smart algorithmic choices. The sentiment behind "don't use Python for performance critical code" isn't wrong, but there's nuance. Programmers should make informed choices about space and time complexity regardless of the language being used.

Your typical assembly programmer may be far more aware of their obligation to do so than your typical Python programmer, so in my mind it's more important that languages occupying Python's ecological niche behave predictably. It can be challenging to balance that need against other constraints like limiting the number of abstractions someone needs to master in order to be productive.

Sure assembly is overkill for most tasks, but Python's performance is so poor that you can sometimes write a brute-force double loop on C++ and have it outperform anything in native Python.

Sometimes raw performance does save developer time, because you don't have to worry that much about algorithm. :)

Preaching to the choir. It amazes me that the ML and Data Science folks have settled on anti-FORTRAN. (Or maybe, put that way, it’s less amazing.)

That depends on what you are building with the language. There are a lot of use cases outside web apps in Python. The majority of them, I'd argue.

Steam is the very opposite of a walled garden.

Putting them in the list but leaving out all console manufacturers and operating system devs? Strange.

I think all gaming consoles are similar. It's actually because steam is something I use while consoles aren't that I didn't think about that.

Blender is doing so good nowadays it is crazy... Everyone is supporting them.

I hope they keep the team smallish as always!

It depends on the percentage of users do so.

This strikes me as a pretty narrow view of the hacker mindset. Sure, "hype-driven" is not exactly hacker-y, but "reckless," "for fun," and "why not" all sound exactly like hacker attitudes to me. A prime example would be Claude Shannon, who built tons of useless overcomplicated things just for fun in addition to coming up with information theory.

> It's been huge leap in reducing cost to build, distribute, learn and use apps.

Citation needed.

20 years ago you could make a commercial app with a GUI in no time with things like Delphi or Visual Basic.

Now to do the same we have to learn several standards and languages and libs/frameworks and build tools and server admin tools and...

I think the key differentiator is in distribution. If you build a web app it's immediately available to a sizable proportion of the human population (not that they'll necessarily use it). Getting similar reach with something offline is much harder.

As you say it's still not trivial (legacy browsers, funny standards, technical challenges of serving loads of users etc.) but Id argue it is substantially easier than the challenges involved in making a program written in visual basic available to billions of people.

People back then downloaded the program and ran it. Online distribution, web browsing, etc. was already a very common thing 20 years ago, specially in certain countries and businesses.

And publishers were readily available too, like for any other physical item.

If something was wanted, it did not matter, it would sell and distribute itself. Take a look at things like Lotus, Office, Windows, Doom...

I strongly prefer the native, compiled software of the old days, and dislike webapps. There's only a handful of webapps that I find useful and usable, while the majority feels unresponsive, resource hungry, and generally a step back from late-90s software.

At the same time, I absolutely think it's the online distribution of webapps that is the killer feature. People only need a URL. There's no download and install process (and the less tech-literate users often had difficulties with that), and perhaps even more importantly, there's no patching. As a developer, you know that all your users are running the latest version you got deployed. You don't have version 1.0, 1.01 and 1.12 floating around the Web as downloads, you don't have to beg people to download and install the patches, you just deploy to the production server and that's an automatic update for everyone.

That is IMO why browsers won as an application platform. In my very limited experience coding for the web, it's a remarkably bad application platform. You don't have many useful primitives. You don't really have a choice of language. You're beating protocols meant for documents into submission so they become useful for apps. It's more difficult to create a UI than it was in Visual Basic, Delphi or Borland C++, and so on. But for all of that, you get an application that someone can start using after clicking one link, and that will transparently auto-update.

With Stores those points are solved. Prominent ones like Valve, Apple, Google, Microsoft etc offer automatic updates, URL discovery, one-click install and stuff like that. They even have extra benefits, like reviews from actual users vs marketing landing pages of web software.

Browsers have "won" for other reasons: licensing control, unavoidable analytics, subscription mechanics... All that combined is a dream for a publisher.

I think you're getting ahead of your point, here.

> With Stores those points are solved. Prominent ones like Valve, Apple, Google, Microsoft etc...

didn't exist 20 years ago...

> Browsers have "won" for other reasons: licensing control, unavoidable analytics, subscription mechanics...

And those stores (and the native app platforms they reinforce) is what allows all these things in native apps, and makes them quite a bit harder to block than in web apps.

> didn't exist 20 years ago...

So what? I haven't said anything about that.

As a data point, Steam (as a store) was already there 15 years ago.

> And those stores (..) is what allows all these things in native apps

Stores don't change what a native application can or cannot do.

>> didn't exist 20 years ago... > So what? I haven't said anything about that.

If the old native apps were the gold standard, modern distribution wasn't part of that. If we include modern distribution, then all the supposed advantages you cite for browsers "winning" apply just as well to native apps. And yet.

> Stores don't change what a native application can or cannot do.

and yet all those stores provide licensing control (and DRM), analytics, and subscription mechanics, often unavoidably (Apple) or unavoidably in practice (Google and until very recently, Steam).

I mean, websites (and apps) are cross platform. That fact alone reduces a ton of development time and mental overhead.

You could do cross platform UI with Java. It was slow, ugly and poorly integrated with the rest of the OS unless you put in extra effort for each platform.. Just like applications running in the browser today.

I struggle to conceive an alternative. I don't want to download a native app every time I want to access my bank account or browse Twitter, for example. Web applications, despite their glaringly obvious flaws, are undeniably convenient.