I like it when type systems can express this kind of constraints. It clearly allows to catch mistakes early in the development cycle.

This is in part a rant but lots of points in there are very valid. This is in part why I don't find Go a very compelling option so far. Modern tooling indeed, nice runtime in some areas but leaves way too much of the complexity in imperative code.

Looks like it's still in the very early days but the overall approach looks interesting.

Interesting use of Rust behind a Python API. This is IMO an interesting niche for the language.

Interesting and fair list of pain points around Rust. This is a change from the pure fan boy articles we see most times.

Interesting use of WebAssembly for fast and very portable code. Also especially interesting is the care in the move to the new software architecture.

Interesting example of using a strong type system to avoid mistakes in code using a parsing and serialization library. The fact that it's about IMAP and I'm still traumatized by it has nothing to do with my interest in that article, really.

This is good to see this is still making progress.

This is a good highlight of the differences. It's not "one is best", it is really "pick what is best in your context".

Sounds like a potentially interesting tool especially combined with curl.

Nice description of the community management in the Rust community.

The journey of Rust inside of the Linux kernel is still in its early days. I find especially interesting the questions raised by the community. It's especially healthy in my opinion, it's not just "fancy let's have it". They also wonder about the learning path for people to join the community if it's accepted or where to best use it. It's a good account of the social aspects triggered by technical changes.

Nice comprehensive list of the smart pointer types in Rust.

This is Rust focused but still, shows a good way to increase binary portability across distributions. I suspect a couple of things would be easier with elf-dissector even.

The use of PyO3 keeps being very interesting for Rust / Python interoperability. The porting experiment in this article is well done and shows well the strength and weaknesses of both.

Interesting use of Rust to optimize an otherwise completely Python base code. This is properly done, first profiling the problematic system finding where the bottleneck is, evaluating other options first, then finally biting the bullet. Leads to a dramatic improvement by just replacing a few lines of Python. This is far from the "let's rewrite everything in Rust" which is a good thing.

Interesting take, it's a bit what I feel coming from C++ and keeping an eye on Rust, it's accumulating features fast and there's a risk of things becoming inconsistent.

Still keeping an eye on what's available for crunching numbers in Rust. Apache Arrow looks like an interesting option.

I like when papers aren't about "mine is better than your". This is an interestingly balanced take on those two popular option showing where they fit best. Shows good reasons for a polyglot approach: as usual use the best tool for the job.

Somehow states the obvious: you don't always need docker. Still a good reminder, especially true with the trend of single binary web services like what can be achieved with Go and Rust.