I think it's worth trying!

Is Rust still considered "new hotness"? I feel like the industry has long-since moved past that perceived "blocker".

It seems like Rust is now just the default in all manner of critical systems.

Don't hate me for this, but... is 20 years of Rust really new?

https://en.wikipedia.org/wiki/Rust_(programming_language)

I do get what you mean, but Rust has been baking for a decade, finally took off after 10 years of baking, and now that is been repeatedly tried and tested it is eating the world, as some developers suggested it could eventually do so. I however do think this shows a different problem:

If nobody writes unit tests, how do you write them when you port over projects to ensure your new language doesn't introduce regressions. All rewrites should be preceded by strong useful unit tests.

> years of bug fixes and edge-case improvements can't be accounted for by simply using a newer/better code-base.

Partially is in fact true: Just because the Rust use a better type system (after ML) + better resource model (aka borrow checker), and if you are decently good, you eliminate, forever!, tons of problems.

It can't solve things that arise by complex interactions or just lack of port subtle details like in parsing poor inputs (like html) but is true that changing the language in fact solve tons of things.

There are big pushes in pretty much every direction. The projects that really stand out to me are pyo3 (Replace c++ python modules with rust), Dioxus (react-like web framework), The ferrocine qualified compiler (automotive)

I think right now the ecosystem is pretty ripe and with DARPA TRACTOR there are only more and more reasons every day to put rust on your toolbelt.

I am secretly hoping that eventually we break free from the cycle of "hire a senior dev and he likes rust so the company switches" over to hey let's hire some good mid-level and junior rust developers

Most of the platforms were successfully petitioned to have rust sdk mandatory added so that rust code can be added to the platforms. The previously situation was rust was not allowed because the external dependency of the rust sdk was blocked.

Note that the rust having no stable api is not fixed, so I think there's a bunch of internal systems on each platform to hard lock the rust dependencies across multiple rust users.

There's some friction between platform packagers and the code that the author wrote exactly as it was written.

AI has made it exceptionally easy to program with.

I've switched to using Rust from Python simply because of AI development

What do you mean by “these days”? To me, it seems like rust is a pretty constant factor on HN for at least two years now.

there has been a few adopters of rust... linux formally choosing it for some of their systems being the most notable recently(maybe a few months ago).

The C ABI can already be used, it comes with all the existing safety guarantees that C will provide. Isn’t this as good as C?

> Until that happens, it'll be hard to adopt Rust in a lot of C/C++ strongholds where C's ABI and dynamic linking are the thing that enables the software to get huge.

Wait, Rust can already communicate using the C ABI. In fact, it offers exactly the same capabilities as C++ in this regard (dynamic linking).

Dynamic linking is also great for compile time of debug builds. If a large library or application is split up into smaller shared libraries, ones unaffected by changes don't need to be touched at all. Runtime dynamic linking has a small overhead, but it's several orders of magnitude faster than compile-time linking, so not a problem in debug builds.

C++ ABI stability is the main reason improvements to the language get rejected.

You cannot change anything that would affect the class layout of something in the STL. For templated functions where the implementation is in the header, ODR means you can't add optimizations later on.

Maybe this was OK in the 90s when companies deleted the source code and laid off the programmers once the software was done, but it's not a feature Rust should ever support or guarantee.

The "stable ABI" is C functions and nothing else for a very good reason.

Indeed, Victor Ciura from Microsoft DevDiv has several talks on how this is currently an adoption problem at Microsoft.

They have been working around it with DLLs, and COM/WinRT, but still the tooling isn't ideal.

Do you have more details? The thread you linked was about gzip, not dd.

> the GPL licenses really do protect open source.

They did, until the automatic copyright laundering machine was invented. Pretty much every piece of GPL code ever written is now being magically transmuted into MIT/BSD or proprietary code, and the FSF has no solution.

A discussion on licenses will go sideways very quickly. GPL does limit the adoption of software in certain environments. So it really depends on your goals. Do you want an OSS project that will be useable by everyone (including corporations) or do you want to guarantee that the software will always be OSS and guarantee that Corporations can’t benefit from it without contributing back (potentially requiring them to open their own proprietary code).

There’s a lot of moral perspective that people apply to this decision, but not all developers have the same goals for their software. MIT is more flexible in its use than GPL, but doesn’t help ensure that software remains open.

What evil deeds are you worried about in particular? What are you afraid people will do now that coreutils is MIT?

Wow that is pretty careless, and you are being downvoted for pointing it out.

Can't wait for this Rust clown show house of cards to collapse. Imagine a mechanic throwing out all his tools en masse to replace them with trendy new ones. This entire movement is driven by emotions and impulses, immature programmers who don't grasp the concept of leaving done software alone.

You should never trust a mechanic with shiny new tools.

Rust was first