Actually, with Rust you can even link with msvc toolchain, which Go cannot.
579 karma · joined January 23, 2015
Actually, with Rust you can even link with msvc toolchain, which Go cannot.
Note: None of these are cast in stone. These have worked well for us
1. Decide in your team/org what constitutes a new version and what it means. Does every change means version change? What if an API adds an optional parameter; do I need to update the version?
2. Not everything has to be a service. Think if the same functionality can be consumed in the form of a library/sdk instead of a full service.
3. The dependency amongst services should resemble acyclic graph and not cycles. This limits the version change impact.
4. Think about abstraction. Can we logically group set of services A, B & C and provide unified API via pass-through service D? Only D needs to handle API breakage most of the time.
I get the rationale behind the need for different types. When I say quality of life improvement, I meant standard conversion functions between these types which would suffice for most of the use cases. Maybe a separate crate for this would be a good start.
Absolutely spot on! You add Path, PathBuf & ffi into this mix, it becomes tiring very soon. I think a quality of life improvement is needed in this area.
In my experience, sales team rarely have any incentive to help out here. They almost always say that delay will create problems and they quantify in terms of dollars e.g. If X is not done by this date we will lose Y dollars. That Y number is almost made up to make things more urgent.
Actually, I have seen sales blaming lack of sales numbers on engineering because the delivery was "too" late.
[1] https://www.environment.gov.au/protection/ozone/ozone-scienc...
How does this work? Does the runtime tracks duration for each future?
> spawning a new executor thread
I would imagine that the future object will be moved. And for move to be cheap are they allocated on heap by the runtime?
> The new runtime is small, uses no unsafe
Awesome!
In ideal world perf reviews should not degenerate into this. In real world, it is a zero-sum game. One example is that the budget for giving increments/hikes is always limited. To reward one individual means giving less to someone else. Second example is that of promotions. As you go up the ladder, there are fewer positions and competition is more. I can't see any other way but to stack rank the employees. The criteria used may be flawed, but that does not mean that ranking is not needed.
Talking about criteria: if its too objective people will game it, if its too subjective then all sorts of human factors come into the play.
Finding a solution for this has always been a holy grail and every now and then a company claims that "they-do-it-differently". Even if a company does this really well it only says about that point in time. It is a different thing to sustain that year over year. All companies have issues in their perf review. They only differ in toxicity.
In other languages say C++/Go/Python, you have a shared buffer in two threads. Both threads have mutable access to it but you know only one of them is modifying it at any point of time (because you wrote it :) ). This is not good enough in Rust. You will have to prove it to the Rust compiler at compile time that this invariant is true. In Rust you express this using its type system. Syntactically & semantically it is very different than other languages.
The implication of the above is that in Rust you will have think a lot about your code structure & data-flow upfront compared to other languages else you will hit the wall very frequently. Some people say this is how it should be anyway & others think it as impediment to the productivity. Both points are valid in my opinion ... it more of a question of cost vs benefit.
Also, this has all the goodness: open-source, high quality engineering, design in open, large contributors to a complex piece of software. Truly inspiring!
With Rust, its entire ecosystem (however nascent) is subjected to the same strict rules. This is big plus when Rust eco-system matures functionality wise.
From personal experience: Our company had tailor made use-case to use Rust (switching from Python), more than Go. Experiments were performed and Rust outperformed Go in all aspects (time, CPU, memory). Everyone acknowledged but CTO (who knows C/C++ very well, he is a filesystem developer) decided to select Go. CTO was bullish on Rust to start with but developed cold-feet later. He told me that the only reason was that it is easy to train people in Go than in Rust. This one single thing trumped everything in my case. When I look back, I see his point & I respect that.
While issues like portability, eco-system, ABI stability, etc are important, these are not inherent problems with the language itself. They will get better over the time.
Besides this, I did learn a trick or two from the blog.
"Power resides where men believe it resides" - Varys, Game Of Thrones
Reminds me of the movie "October Sky". Highly recommended.
The thing is when I moved back from Rust to Go, I had forgotten how productive Go is and I felt something like this:
https://youtu.be/1i_Eqj7wu88?t=50 (20-30 sec video)
As someone who tried to "sell" rust in my org, I see the biggest issue is:
1. Steep learning curve (it is true)
2. When lot of people talk about #1 it gets amplified in the minds of people who make calls on the tech to be used
A great effort has been spent on #1 and I agree the payoff is worth it. But #2 is perception/marketing issue.
PS: I am huge fan of both Rust & Go.
The testing each release goes through is quite impressive. I bet more time is spent on testing (or writing tests) than actually developing the features.
I do this in my case but for different reasons and not performance.
Technology definitely solves lot of problems and some tech enables to scale the solutions (e.g. discovery of antibiotics and tech to mass produce them). But then it gives rise to new set of problems which are much harder to solve. The harder the problems get more collaboration and working together is needed at global scale, which itself is very hard. In this sense, tech can only go so far.