No. “Hello, world!” or you’re doing it wrong.

but it can lead to absurdly high version numbers

I have a really hard time seeing this as a problem. Why is 125 an “absurd” version number? You’ve presumably done 125 patch versions since the last minor version, so doesn’t it just make sense?

It’s just a number, it doesn’t matter if it’s “high”.

Linux doesn’t use semantic versioning, right? So this is just an arbitrary number?

Might not be new but it’s not been posted here before :)

Not nearly as readable though

I don’t agree with the comment there. In my mind, the LTS release would not mean anything. It would just be a label on an arbitrary release every couple of years. I feel it could help the ecosystem align on which MSRV to choose, so that you don’t have one crate choosing 1.x, another chooses 1.(x+1) and another chooses 1.(x+5). It would be nice if we just sort of agreed that if you care about your crate being used by somewhat older compilers, use the LTS version and consider the implications if your MSRV go beyond that version.

Of course any crate author is free to completely ignore this and choose whatever MSRV they desire. But perhaps a significant amount of authors would put at least a little effort (but not much) in trying to avoid raising the MSRV above the LTS version, just as authors may try to avoid breaking changes and such. It’s just a nudge, nothing more.

An LTS release scheme, combined with encouraging libraries to maintain MSRV compatibility with LTS releases, could reduce this friction.

This actually sounds like a good idea. Currently crates are choosing their MSRV all over the place. If we just got a bit of alignment by calling every ~17th Rust release (roughly 2 years worth of releases) an “LTS” release, then crates could be encouraged to keep their MSRV compatible with that release.

But we also heard a consistent shape of gaps [in core]: many embedded and safety-critical projects want no_std-friendly building blocks (fixed-size collections, queues) and predictable math primitives, but do not want to rely on “just any” third-party crate at higher integrity levels.

I think some fixed-size collections and stuff like that would be super nice in core. Something with simple, predictable semantics, just like Vec has (i.e. no optimizations for certain usage patterns, like small string optimizations and that sort of stuff). With const generics working for integers, fixed size collections in core shouldn’t even be that hard (it’s certainly been done in many crates already).

Rust programs can definitely still consume a lot of memory. Not using a garbage collector certainly helps with memory usage, but it’s not going to change it from gigabytes to kilobytes. That requires completely rethinking how things are done.

That said I’m very much in favour of everyone learning Rust, as it’s a great language - but for other reasons than memory usage :)

This is the way with modern software engineering, especially in the industry. It comes from the basic fact that:

1. Companies want to get code for free from the internet - someone else already wrote that code, let’s use it for free and have better profit margins!
2. Companies do not want to spend time and effort vetting that free code, as that would make it… well, not free. That would require manpower (perhaps unless you trust AI to do it these days…) and that’s money.

Basically they want to eat their cake and have it too. This applies to all modern package managers for modern languages that make it easy to distribute your own code and consume free online code.

I doubt the industry will ever mature to a point where this will stop, as the tradeoff of getting free code with no work is just too good for most companies, especially the smaller ones.

Billboards and other physical ads and such suck but are thankfully already mostly illegal where I live.

Problem with other kinds of advertising is that it can’t be made illegal, not truly. People would still do it, it would just not be marked as such. I’m not sure how to fix this.

Have you tried the Rust book? I learned via that and it’s great.

I think that’s quite harsh. As I said, I know it’s not what OP asked and it was just a suggestion. I’m just adding it as an option. Perhaps someone else reading the thread will find it useful, if not OP (who I don’t think you should speak for).

OP mentioned they want native speed and were struggling with badly documented libraries. I feel like it was appropriate to at least mention Rust, considering those two things. Since when is widening a discussion slightly considered bad? You don’t have to reply to my comment either, if my comment does not seem interesting to you. Let alone downvote it. You can just leave it alone, it doesn’t hurt anyone.

Not that cool maybe but I once played a lot of Pathfinder (1st edition). I made a website with a detailed database of all the items in Pathfinder with very specific filters and also including a random item generator. You can try it out here:

https://sortekanin.com/collection/items/

I know it’s not really what you’re asking, but have you considered learning Rust? In many ways, Rust is more similar to C than C++ and is just as capable. There are quite a few very well documented (as is common in the Rust ecosystem) Rust libraries for GUIs, including efficient native ones or immediate mode ones and such. Just a suggestion.

Warcraft 3 custom maps still drag me back sometimes.

I think you’re misunderstanding the never type. The never type is not a hack at all. It’s a very natural part of the type system. Just as you have the unit type (), which is the canonical type with only 1 value, you also have the never type, the canonical type with 0 values.

This is extremely useful in generic code. See my other comment in this thread.

This is an unfortunate wart to appease a desire to those that want to be able to write code like they do in legacy languages

What do you mean with this? I can’t really decipher it. What alternative to the never type would you want?

shouldn’t Rust enforce returning from function

This is impossible. How would you enforce that? What prevents a function from panicking, aborting the whole process or just going into an infinite loop? All these things correspond to the never type.

I think you’re misunderstanding what the never type is. It’s not equivalent to None at all. It’s a type that doesn’t have any values. This is useful in situations with generic code where for example an error type can be chosen as the never type. Then you could destructure or unwrap a Result without handling the error, cause the type system guarantees the error never occurs.

I think you should read up on the never type a bit more. It’s a perfectly natural part of the type system. In fact you can make your own very easily: enum Never {}

Can’t wait for the never type to be stable :D

There are now, fortunately, plenty of low carb, low glycemic products that are a lifesaver when you have cravings.

What products are you thinking about?

That feels relatively young for something like that, I would’ve thought maybe that would’ve been a little further back.

In some ways it does go further back, because each village basically had its own time. So there were lots and lots of time zones, if you think about it that way.