Comment by nindalf | Hacker News Reader

Comment by nindalf | Hacker News Reader

Parent Full thread

Your sentiment is a commonly expressed one, but not usually by people who have adopted Rust. It’s usually Clang/MSVC/GCC users who have decided this is the optimal flow and want to replicate it in all future codebases they work in, regardless of language.

In reality if you hit a compiler bug in Rust or Go (or any other language with one main impl like Python, Ruby…) you would file a report and do one of two things - downgrade the compiler (if it’s an option) or write the code a different way. Compiler bugs in these languages are rare enough that this approach works well.

That said, for people who are really keen on a spec, there is one being worked on (https://blog.rust-lang.org/inside-rust/2023/11/15/spec-visio...).

But this GCCRS effort doesn’t get you any closer to your ideal C/C++ style workflow because they are committing to matching the semantics of the main compiler exactly. Bugs and all. And that’s the way it should be.

The Rust ecosystem becomes worse if I have to install a different toolchain and learn a different build system with a different compiler for every new project I interact with. And after all that extra effort it turns out there are subtle differences between implementations. My developer experience is just worse at that point. If I wanted to code like this, I would code in C++ but I don’t.

> Your sentiment is a commonly expressed one, but not usually by people who have adopted Rust.

Perhaps because it’s currently not possible in Rust, so users don’t really see the advantages yet.

Multiple implementation are always a good thing. They bring in diversity of thought and allow for some competition in the implementation. Having multiple slightly different implementations also gives more clarity to a spec.

This isn’t the kind of stuff that users tend to think about until it’s already there.

I agree there is value to multiple implementations. We wouldn't be where we are today with open compilers and efficient machine code if it weren't for the competing implementations of LLVM and GCC.

However there isn't enough benefit to multiple language _frontends_ that I can see that outweighs the many downsides.

Not only do you have to contend with the duplication of effort for implementing two or more language frontend projects, you now create ecosystem splits when inevitably the implementations do not match their behavior.

The biggest example of multiple frontends, C++, is not one language. C++ is Clang-C++, GNU-C++, MSVC-C++, and so-on. All of these implementations have subtle incompatibilities with how they handle identical code, or they have disjoint feature matrices, or they have bugs, and so on. Multiple frontends is IMO one of the _worst_ parts of C++ because it makes writing truly portable code almost impossible. How many new C++ features are unusable in practice because one of the main 3 toolchains hasn't implemented it yet?

Rust, on the other hand, everything is portable by default. No #ifdef CLANG, no wrangling with subtly incompatible toolchains. If I write code I can trust it will just work on any architecture Rust can build for, ignoring implementation bugs and explicitly platform specific code.

I have a hobby game engine I work on in my spare time that was developed exclusively on x86-64 for years and I ported it to run on Apple Silicon ARM in two afternoons. Rust just _worked_, all the time was spent on my C/C++ dependencies and new code needed for MacOS support.

I simply don't see how nebulous, difficult to quantify benefits of competing implementations can outweigh the practical advantages of truly portable code that comes from a single implementation. The ecosystem benefits to a uniform language, and the benefits to my sanity with being able to trust my code while compile everywhere I need it to.

Writing truly portable C++ it’s not all that hard. In the worst case you need a handful of ifdefs even if you write systems code.

#ifdefs are a signed of ported code, and not portable code.

If you need a few hundred lines of ifdef in a codebase with millions of lines it is portable in the sense that you are able to port it with reasonable effort.

That's nice, you're welcome to continue writing your ifdefs. Nothing you or anyone else has said has built a compelling case for alternate frontends. You're saying "it's not much effort". Sure, but I prefer 0 effort.

What we're saying is that everyone actually using Rust today is fairly happy with how the language is. That's why Rust has had an 80%+ approval rating among Rust developers since its creation and C++ is at 49% (https://survey.stackoverflow.co/2023/#section-admired-and-de...).

This suggestion of alternate frontends still has no good technical reason driving it, just people pattern matching on their past experience. If it happens, all it will do is lower Rust's approval to C++'s level.

If only alternative frontends were the only reason that C++ developers were unhappy with the language...

Only #if you ignore the hundred other issues with building portable c++ code:

* Libraries * ABIs * Build system(s) * Platform compiler support...

In compiled/interpreted land, most if not all of these are solved problems. Even for libraries, usually dependencies can be reliably downloaded and recompiled (if they are not compiled on the fly).

I don't really care if you can create a "portable header" library when the ecosystem is sharded, and "portable" only holds true for some subset of c++ compiler/platforms.

That seems orthogonal to having multiple frontends. I have in fact worked on several systems that compiled under three compilers and ran on multiple architectures and/or operating systems and it was not a hot mess of ifdef spaghetti.

Its orthogonal to ifdef sphaghetti so long as that's not in support of the (general) sphaghetti.

I'm not specifically commenting on ifdefs, because ifdefs are only a small part of the issue (caused by multiple compiler frontends).

It's bad enough already when there's a single implementation, but people can't agree which version increment has left the newfangled stage.

That is dumb and counterproductive. Your entire scenario presupposes unlimited labor capacity and funding (monetary or otherwise), so “diversity is better!”

In reality, the people wasting their time to produce a redundant ground-up rewrite of existing functionally could have spent their time and effort on something else that actually moves the world forward.

I think the only thing I’m assuming here is that there are people who want to do the work. Perhaps because it’s fun to write a compiler (it is!), or because they don’t view llvm as the pinnacle of compiler technology, or maybe their employer sees value in it.

And apparently there are people who want to do the work, because we have work on a couple of implementations.

You can choose to use your one true implementation, no one is stopping you. But it’s kind of weird to assume that people working on another one are detracting from yours. That’s not usually the way open source software works.

That's only true if you are not distributing your code. If you want to kill portability just involve MSVC in anything.

All i hear is fragmented ecosystem.

Have you had your ears checked lately?

Nah, they’re right.

Monopoly is never the optimal flow.

Sincerely,

- Rust adopter

Monopoly rings hollow when it comes to a community open source project.

Monopolies are bad when they stifle progress, but rust's written under a free software license. At any point, anyone can take the project and fork it into a new one, can carry on the progress under a new flag.

Unlike traditional monopolies, the rust project's priorities aren't extracting profits or holding power, but rather in improving the language, and they're open to anyone (well, anyone who's tolerant of others) joining and helping.

The argument here is that we will end up with a better outcome if we work together as a community, rather than if we fragment just for some perceived ideal of multiple implementations.

While you're criticizing the rust monopoly, you might as well go and also yell at the group of friends voluntarily picking up trash off the sidewalk for free since they're working together as one monopoly of friends instead of creating two competing cleaning groups.

> Monopoly rings hollow when it comes to a community open source project.

Last I heard `open source` was used to refer to code not projects.

Every project has its "decision makers" (no matter the structure or titles) that have the power to dictate the direction and vision. You can literally see it every day in many projects, not trying to single out Rust or anything. The power is not distributed evenly, not even within the elite inner circle.

There's no 'together as a community` when it's followed by a clause like `we need to follow the one direction (X) has set`.

What power does `the community` exactly have? to open a PR and get denied? is to fork? Can the community ellect leaders and change course? You said it yourself, anyone that want to have their voice heard, they have to climb up the ladder and join the inner circle. You're descriping `Power elite` and not `community`. Even forks don't work in real life, what happens is the project usually die slowly and everyone move to the next thing.

I'm not dismissing the structure itself, it's a good pragmatic approach, it's just that you're twisting and polishing it. In short:

  You: Everyone is welcome. No need to fragment. Rust is run by community.

  Rust's governance: We rule. We also pick any new members. Community doesn't have much say about anything.

So pursuing efforts like the one in the post is exactly how the community is empowered and what might enable Rust to survive any challenges it faces in the future. People doing their own things is how the open source ecosystem began and continue to flourish. So can you just welcome their effort and let them be?

Reminds me of iron law of oligarchies. Which basically is true of any group.

> rust's written under a free software license

the way you are using "free" is undefined behavior. "Free" as in speech software, the F in FOSS, is associated with copyleft FSF and GNU, and not like BSD, MIT, and Apache, the open source in fOSs, which is what Rust is.

The english language is full of ambiguity if you choose to be pedantic, yet somehow most people manage to communicate.

The fact that you knew I was referring to rust's license means my English was in fact not undefined, but exactly as clearly defined as one can hope english to be, i.e. we both thought it meant the same thing.

In my opinion, in context, "free software license" is also a clear and common phrase, not undefined behavior.

Essentially, I think everyone has agreed that "free software", unless you add more qualifiers, will refer to the FSF definition of free software https://www.gnu.org/philosophy/free-sw.html

The FSFs definition includes both the licenses rust is licensed under: https://www.gnu.org/licenses/license-list.html#Expat

The FSF would happily call BSD, MIT, and Apache "Free Software Licenses", and in fact do so.

The FSF recognizes BDS, MIT and Apache as Free Software (but not Copyleft) licenses.

no, they recognize those licenses as compatible with the GPL, but not as free software

https://www.fsf.org/

"Free software means that the users have the freedom to run, edit, contribute to, and share the software."

those licenses allow derivatives which users cannot edit and contribute to thus they don't guarantee the 4 freedoms of free software.

That's literally contrary to what FSF says.

Please read: https://www.gnu.org/licenses/license-list.html .

For example:

  Apache License, Version 2.0 
  This is a free software license, compatible with version 3 of the GNU GPL.

Or:

  Expat License [this is the MIT license]
  This is a lax, permissive non-copyleft free software license, compatible with the GNU GPL.

The fact that a license allows derivative work to take away the 4 freedoms don't make the license not a free software license. An end user in reception of a permissively licensed free software can make full use of the 4 freedoms.

Reply on news.ycombinator.com