Your bi-weekly overview of the most popular
Rust articles, jobs, events, and news

26 November 2021, ISSUE #67

IDEs and Macros

"In this article, we’ll discuss challenges that language servers face when supporting macros. This is interesting, because for rust-analyzer, macros are the hardest nut to crack."

Endianness, API Design, and Polymorphism in Rust

I first encountered the concept of endianness when I was first learning to program using the DEBUG.EXE program on DOS. When a 16-bit value was displayed as a 16-bit value, it was just normal hexadecimal, but when it was displayed as two 8-bit bytes, something weird happened with the display.

Contributing to Artichoke in Rust

Artichoke is an implementation of Ruby written in the Rust programming language.

Rust Packages vs Crates

It is a common misconception that packages are crates and visa versa. I will admit that this is a pet peeve. But for Rust coders, it is important to know the difference because otherwise you are denied an understanding of how Rust code is organized, shared and consumed.

Merge Queues with Bors

This post explores several reasons for using a merge queue and describes how to set up Bors, the merge queue implementation used by the Rust language project.

Stack-safety for free?

I demonstrate how to (ab)use generators/coroutines to transform any recursive function into an iterative function with nearly zero code changes.

Undefined Behavior deserves a better reputation

“Undefined Behavior” often has a bad reputation. People see it as an excuse compiler writers use to break code, or an excuse by a lazy language designer to not complete the specification and properly define all this behavior.

Improving overconstrained Rust library APIs

In this guide, we’ll demonstrate how to make Rust library APIs more lenient without losing any functionality.

Calling Rust from Python using PyO3

In this blog post, I will give a short introduction to PyO3. After that, I will discuss several example functions, written in Rust and called from Python.

Box Pointers in Rust make recursive types possible

A pointer is a general programming concept for a variable that contains an address in memory. In Rust, we have smart pointers in addition to normal pointers.

Intrusive Smart Pointers + Heap Only Types = 💞

Rust can model (at least) two kinds of heap-only-ish types: Unsized types, which cannot be placed on the stack by the compiler because their size is unknown, and semantically heap-only types, which are contextually heap-only whenever an API doesn't allow them to be observable elsewhere.

Rust and memory safety

I will give a very generic talk about rust and how rust ensures memory safety. It will be helpful for anyone getting started.

Last Tuesday

What's gonna happen is you're all going to tell me what mind-blowing things you've been doing. /nod

Buffalo Rust User Group, First Tuesdays

Join us at the Buffalo Rust Meetup User Group for casual Rust language discussion and hangout!

Book #24 - Rust for Rustaceans - Chapter 1

In this session, we'll be starting with Chapter 1 - "Foundations". We'll also discuss how often we plan to meet

Rust Audio Developer
Rust Developer
Backend Engineer - Rust - Core Backend
Backend Engineer, Kraken Futures - Rust
Announcing decurse

Macro to make recursive function run on the heap (i.e. no stack overflow).

Announcing decurse_macro

Proc macros for the decurse crate.

Announcing pinned_vec

Vec-like data structure whose elements never move.

Announcing tflite-dyn

Rust bindings for TensorFlow Lite C API

Announcing gamie

A Rust library provides abstractions for several classic tiny games

Substrate Rpc To Call Runtime Api
Expose Stm32F3 Sansor'S Reading


Organizing an event or Meet-up? Promote it with Rust times.


Wanted to contribute or share suggestions?

We love to share relevant articles, events, and jobs with our subscribers. Please contribute by submitting a PR. Also, let us know how we can improve further with your feedback and suggestions.


Featured Books

Stay Connected & Updated!