Rust is famous for strictness in terms of memory management and error handling. But there is also a not very well known and to my mind a bit of a unnecessary stiffness in the type system when talking about trait specialization. Here is a minimal example, you don't not need to be an expert in Rust to understand it.

Basically rust compiler assumes that in the future there might be a type that implements both A and B and therefore this will create a conflict. To my mind this is not needed as this can be intentional design that the traits A and B are not planned to be implemented at the same time.

Currently this can be solved by wrapper type pattern and boxing. But surely this is not very elegant. Hopefully language design team will fix it with specialization, though it is still uncertain when this feature is planned to be released.

Good Design sounds a bit too generic and sometimes people overuse this term as an argument to bring in unnecessary complexity, but I agree with the other points https://twitter.com/graninas/status/1380451255764537345

Wow someone actually believes Java is underrated. Well then I guess if it was properly rated 100% devices would be running Java?😅

This month in Rust Game Dev by @ozkriff

https://rust-gamedev.github.io/posts/newsletter-020

Let's make C++ memory management great again...

https://github.com/zhuowei/nft_ptr

fasterthanlime articles are always fun to read https://fasterthanli.me/articles/so-you-want-to-live-reload-rust

RustViz - Interactively Visualizing Ownership and Borrowing

https://github.com/rustviz/rustviz

Well, yeah, sort of... Though Liskov's Substitution Principle I would argue is purely about objects. But I feel like the principles are rather common and just need to be reformulated in a more general way. It's time we stopped considering OO as the only model that exists 😁.

https://t.co/yuP2yyF7TX?amp=1

Wishlisted.

It's good that remote opportunities now are somewhat fixing the issue. I guess it's one of the positive outcomes of the whole COVID situation.

https://twitter.com/graninas/status/1382906570913284098?s=19

Omg those evil Rust developers😁

I was reading through some thoughts of the Rust newcomers. And in general I think there is a bit of confusion.

Rust is not only about memory safety with lifetimes.

As it is mentioned at the https://www.rust-lang.org/ Rust main goals are reliability and efficiency.

Rust achieves these goals through many different language features and design patterns, and lifetimes are just a part of it. In fact they support the more general concept: ownership model.

Ownership model is undeniably a great helper in terms of reliability. Though lifetimes are just an implementation aspect of it, not the main focus.

In conclusion I would say when trying Rust it's better to go one by one through the book chapters, it tries to show all of the aspects of the language tying them to the corresponding language goals. Rust introduces many new concepts and though lifetimes are maybe the most well known of them, it is just one of the many.

Ruby Ruby Ruby... (Song by Kaiser Chiefs)

*Music fades*

https://twitter.com/editingemily/status/1383509743977697288?s=09

One of the more elegant explanations of the financial side of bitcoin and many other cryptocurrencies.

Paul Graham to his kids:
https://twitter.com/paulg/status/1384040569710682113?s=09

"If we don't use metrics the imposters will win."