Illustrated with Rust in this case, but definitely one of the big advantages of having type systems. Adding constraints (even runtime ones) to your types make it harder for bugs to hide.
Interesting to see what gets confirmed (slow compiler, nice compiler error messages, code quality) or debunked (steep learning curve, interoperability).
Interesting deep dive in Rust and C++23 string formatting features. This shows the differences quite well. It also does a good job at highlighting the pros and cons for each approach.
Interesting post, highlights why it's better when languages are designed in a more community fashion (make sure to read until the conclusion). At least in term of popularity it seems to help.
Indeed, the story of integrating C and C++ with Rust isn't a simple one right now. It might introduce larger attack surfaces. Some improvements are proposed in this paper.
Nice list of patterns leveraging the Python type hints for richer and safer interfaces.
This is currently a real zoo. I knew about a few of them but not that many. I guess it will slowly converge toward a few major options.
Really nice little tool, this is indeed surprising how little code is needed for something like this. Treesitter is definitely a huge help there.
Very nice milestone and interesting tech for sure. Congrats to them!
This is an interesting move. There are good reasons for it in this article. Also some I'm less inclined to take at face value but still, worth keeping in mind.
Nice walk through for a use of PyO3 to make some Python code much faster. Nice to see how useful py-spy turn out to be in such scenarii as well.
People tend to be fixated on the "unsafe" keyword and assuming not using it will make their code devoid of memory safety bugs. Well, it's a bit more subtle than this. It helps you know where such bugs can hide but it can't completely prevent them all the way down the stack.
Not earth shattering benchmark, kind of confirms what we can expect on the concurrency and REST side of things: Rust, Go > .NET > JVM
That's an interesting perspective. Rust definitely gets in the way of iterating quickly indeed which might be a problem to test ideas. Introducing it gradually later is thus a better path. That being said it doesn't always have a great story for mixing with other languages, there are a few tools to help, but nothing I've seen really used in the wild so far (this will probably come though).
Looks like an interesting runtime. Seems to make it easy to create multiplayer 3D experiences. Maybe too easy to be true? I guess I need to find an excuse to test it.
It's good to also see articles which point out the problems with Rust. Overall I find it an interesting language but people tend to oversell it too much. This is a nice reminder it already carries complexity issues.
Oh, that looks very interesting. I'd definitely have use for this. I tend to manage several aws or ssh configs per customers and it's not always easy to deal with. This could lead to a nice separation.
Looks like an interesting (even though young) tool to make your own linters and to analyze code source.
Like it or not, this is definitely filling a very unique niche. It's a very good fit for system software where safety is important and available time limited. There is no better option for now.
Looks like an interesting frontend stack. Still young but probably worth keeping an eye on.