Maybe it's one of those things where a good union is good and a bad union is terrible.
It's easy to say how good a union could be, but will it actually be that good? What kinds of things can go wrong? What weird laws are in place and how could that complicate things?
The bottom line is that if I am happy already, a union is more risk than reward.
"You can and should be judged on the basis of the ideas and opinions that you promote."
That reminds me of the quotation:
"A new idea is a beautiful and fragile thing. Attack people, not ideas."
I don't know who said that first, but I love that quotation. It mocks itself (and other witticisms), and at the same time reminds you to focus your energy attacking ideas rather than people.
In extreme cases, someone can have a lot of bad ideas and you need to challenge them personally. But that's only in extreme cases, and doesn't apply transitively to supporters of the person.
Just because someone else is profiting from you doesn't mean you are wasting money.
Let's say you save $100k. You can either buy a house, or put the money in the stock market. If you put it in the stock market, you get a return but that return ends up going to your landlord's profit. If you but the house you get no return but don't pay the landlord's profit.
In other words, it's an investment. If you believe that the RE market has better ROI, and don't mind being rooted, then go for it. If you believe the stock market has better ROI and you prefer to be mobile, do the stock market.
First and foremost, a language must satisfy some need that is not met adequately by another existing language. Otherwise it's useless.
There are languages already with fast compilers, and some of them are pretty fast and have pretty good semantics.
Rust is really trying to offer a combination of things not available elsewhere: safety, speed, and control. But that innovation is based heavily on compiler features, which have a compile-time performance penalty.
Assuming rust succeeds on delivering an innovative new language, they can secondarily try to improve compiler performance. Or find ways to avoid paying some compile-time costs in certain situations.
Are you talking about efficiency of the compiler or efficiency of the resulting code?
If it's just an inefficiency of the compiler, you can dismiss it. But if it's an inefficiency in the resulting code, then perhaps the many-pass design isn't adequate for teaching optimization.
It's easy to say how good a union could be, but will it actually be that good? What kinds of things can go wrong? What weird laws are in place and how could that complicate things?
The bottom line is that if I am happy already, a union is more risk than reward.