Compilers as Teachers

We like to stress that Rust takes its commitment to developer friendliness very seriously, and that the Rust compiler considers confusing error messages a bug.

https://ferrous-systems.com/blog/compilers-as-teachers/

@DevMisc
#rust #compiler

How to write slow Rust code

How I tried to port Lisp code to Rust and managed to get a much slower program... and how to fix that!

https://renato.athaydes.com/posts/how-to-write-slow-rust-code.html

@DevMisc
#rust #performance

Why should you learn Rust?

Rust is safe. Rust’s memory safety guarantees that you never have to worry about SegFaults or anything of the sort.

https://betterprogramming.pub/why-rust-d52516e70ab8

@DevMisc
#rust #overview

Writing an OS in Rust 🦀

This blog series creates a small operating system in the Rust programming language.

https://os.phil-opp.com/

#rust #tutorial #lowlevel

Rust vs C++ – which is better and why

Both Rust and C++ are system programming languages, which means they can be used to write low-level code like kernels...

https://federicoterzi.com/blog/rust-vs-cpp-which-is-better-and-why/

@DevMisc
#rust #cpp #webasm

CPU6502

A non cycle-accurate emulator implementing all legal 6502 opcodes, written in pure Rust.

https://github.com/BRA1L0R/cpu6502

@DevMisc
#OG #rust #emulator

Backdooring Rust crates for fun and profit

Supply chains attacks are all the rage these days, whether to deliver RATs, cryptocurrencies miners, or credential stealers.

https://kerkour.com/rust-crate-backdoor/

@DevMisc
#rust #security #misc

A fast port scanner in 100 lines of Rust

https://kerkour.com/rust-fast-port-scanner/

@DevMisc
#rust #nmap

The Rust CUDA Project

An ecosystem of libraries and tools for writing and executing extremely fast GPU code fully in Rust.

https://github.com/RDambrosio016/Rust-CUDA

@DevMisc
#rust #gpu

@DevMisc
#meme #c #rust

Rust vs Go… obvious choice

https://www.youtube.com/watch?v=4O-lXoI2opA

@DevMisc
#golang #rust #satire

@DevMisc
#meme #rust

Rust runs on everything, including the Raspberry Pi Pico

For god's sake, please don't use MicroPython.

https://youtu.be/Yi0WRF5WPFw

@DevMisc
#rust #embedded #raspberry

Futures Nostalgia

https://fasterthanli.me/articles/futures-nostalgia

@DevMisc
#rust #async #hyper

The curse of strong typing

Someone, somewhere made a decision. "From now on", they declared, "all our new stuff must be written in Rust".

https://fasterthanli.me/articles/the-curse-of-strong-typing

@DevMisc
#rust #learn #misc

@DevMisc
#rust #meme #extra

const fn: Pure Functions in Rust

I was taught formal methods at university but these ultra-safe development techniques are expensive, require using unusual external verification languages, and most damning for web and application developers, they slow down iteration.
After graduating and getting a webdev job, I despaired that the safety and guarantees of the formal systems that I had been introduced to weren't available to me as a web developer.
I was going to have to act if I wanted to live in a different world.

https://www.youtube.com/watch?v=voRBS0r4EyI

@DevMisc
#rust #fp #purity #learn

Replacing FastAPI with Rust — A series

The author is starting a blog series exploring the possibility of replacing the FastAPI Python web framework with the Rust programming language for their use case. FastAPI is the author's go-to backend framework, but they are interested in moving beyond some of the limitations of Python. The key requirements the author is hoping to achieve with a Rust-based solution are high performance, type safety, and ease of deployment. The author is unsure where this exploration will lead, but is excited to document the process and see if they can create a compelling alternative to FastAPI. Readers are encouraged to follow along, provide feedback, and suggest ideas for the blog series.

1. Intro (defining requirements)
2. Research (rweb, rocket, paperclip)
3. Trying Actix (actix-web)
4. A Solution (rweb, dropshot, rocket with okapi)
5. Rocket 0.5 (rocket, async tests, memory management)
6. AWS Lambda (AWS CDK)

@DevMisc
#rust #fastapi #rocket #learn

Understanding Rust futures by going way too deep 🦀

The text is a deep dive into understanding Rust futures. It starts by setting up a basic Rust project and adding dependencies like tokio, color-eyre, and tracing. It then demonstrates how to make a simple HTTP request using the reqwest library. The author explains that futures in Rust are just state machines that don't do anything until they are polled, which is demonstrated through creating a "dumb future". The text then dives deeper into the internals of Rust futures, showing how to inspect the call stack when things go wrong, even using unsafe code to cause a segmentation fault. The overall message is that Rust futures are powerful but require understanding their underlying mechanics to use them effectively.

https://fasterthanli.me/articles/understanding-rust-futures-by-going-way-too-deep

@DevMisc
#rust #async #learn