links.txt

Number: 353  Date: 2020-08-26 

### Official
### Tooling
* [Contributing to the IntelliJ Rust plugin](https://kobzol.github.io/rust/intellij/2020/07/31/contributing-0-setup.html)
* [IntelliJ Rust Changelog #129](https://intellij-rust.github.io/2020/08/24/changelog-129.html)
* [Rust Analyzer Changelog #39](https://rust-analyzer.github.io/thisweek/2020/08/24/changelog-39.html)
### Newsletters
* [This Week in Veloren 81](https://veloren.net/devblog-81/)
* [The Embedded Working Group Newsletter - 25](https://rust-embedded.github.io/blog/newsletter-25/)
### Observations/Thoughts
* [A Story of Rusty Containers, Queues, and the Role of Assumed Identity](https://dev.to/pnehrer/a-story-of-rusty-containers-queues-and-the-role-of-assumed-identity-kl2)
* [As above, so below: Bare metal Rust generics](https://www.ecorax.net/as-above-so-below-1/)
* [First thoughts on Rust vs OCaml](https://blog.darklang.com/first-thoughts-on-rust-vs-ocaml/)
* [The problem of safe FFI bindings in Rust](https://www.abubalay.com/blog/2020/08/22/safe-bindings-in-rust)
* [That's so Rusty!](https://dev.to/imaculate3/that-s-so-rusty-3akm)
* [Profiling Doesn't Always Have To Be Fancy](https://www.justanotherdot.com/posts/profiling-doesnt-always-have-to-be-fancy.html)
* [Why I like Piston, A Rust game engine](https://kai.coding.blog/why-i-like-piston)
* [The CXX Debate](https://steveklabnik.com/writing/the-cxx-debate)
* [video] [Bending the curve: A personal tutor at your fingertips](https://youtu.be/Z6X7Ada0ugE)
### Learn Standard Rust
* [Why can't I early return in an if statement in Rust?](https://www.christopherbiscardi.com/why-can-t-i-early-return-in-an-if-statement-in-rust)
* [Bleed Less during Runtime with Rust's Lifetime](https://blog.knoldus.com/bleed-less-during-runtime-with-rusts-lifetime/)
* [A Javascript Developer's Cheatsheet for Rust](https://tndl.me/blog/2020/rust-javascript-cheatsheet/)
* [video] [RustConf 2020 - Macros for a More Productive Rust](https://youtu.be/dZiWkbnaQe8)
* [video] [RustConf 2020 - Rust for Non-Systems Programmers](https://youtu.be/BBvcK_nXUEg)
### Learn More Rust
* [Different levels of Async in Rust](https://www.fpcomplete.com/blog/different-levels-async-rust/)
* [How to run Rust on Arduino Uno](https://dev.to/creativcoder/how-to-run-rust-on-arduino-uno-40c0)
* [Let's build a single binary gRPC server-client with Rust in 2020 - Part 1](https://dev.to/tjtelan/let-s-build-a-single-binary-grpc-server-client-with-rust-in-2020-part-1-3cnk)
* [Writing a Test Case Generator for a Programming Language](https://fitzgeraldnick.com/2020/08/24/writing-a-test-case-generator.html)
* [Day 12: Write web app with actix-web - 100DaysOfRust](https://dev.to/0xbf/day11-write-web-app-with-actix-web-100dayofrust-1lkn)
* [Kernel printing with Rust](https://not-matthias.github.io/kernel-printing-with-rust/)
* [Running Animation in Amethyst](https://mtigley.dev/posts/running-animation/)
* [PL] [CrabbyBird #0 Pierwsza przygoda z Rustem i Godotem](https://postacnormalna.pl/pierwsza-przygoda-z-rustem-i-godotem/)
* [video] [Build a Smart Bookmarking Tool with Rust and Rocket Video Series](https://www.youtube.com/playlist?list=PLzIwronG0sE56c6hDYOKW3-rPxmIyttoe)
* [video] [RustConf 2020 - Error Handling Isn't All About Errors](https://youtu.be/rAF8mLI0naQ)
* [video] [RustConf 2020 - Under a Microscope: Exploring Fast and Safe Rust for Biology](https://youtu.be/2b8InauuRqw)
* [video] [RustConf 2020 - My First Rust Project: Starting a 2D game with Amethyst](https://youtu.be/GFi_EdS_s_c)
* [video] [RustConf 2020 - Controlling Telescope Hardware with Rust](https://youtu.be/xlVnp7VOxRE)
### Project Updates
* [Rustsim becomes Dimforge](https://www.dimforge.com/blog/2020/08/18/rustsim-becomes-dimforge/)
* [Announcing the Rapier physics enginge](https://www.dimforge.com/blog/2020/08/25/announcing-the-rapier-physics-engine/)
* [defmt, a highly efficient Rust logging framework for embedded devices](https://ferrous-systems.com/blog/defmt/)
* [Scaling Bevy](https://bevyengine.org/news/scaling-bevy/)
* [One year of Nushell](http://www.nushell.sh/blog/2020/08/23/year_of_nushell.html)
### Miscellaneous
* [Rust-style futures in C](https://axelforsman.tk/2020/08/24/rust-style-futures-in-c.html)
* [Porting a Golang and Rust CLI tool to D](https://blog.pingfrommorocco.com/2020/08/porting-golang-and-rust-cli-tool-to-d.html)
* [How to Read First Impression Posts](https://www.possiblerust.com/community/how-to-read-first-impression-posts)
* [audio] [The Virtual World - Embedded Rust & Ferrous Systems - James Munns](https://anchor.fm/the-virtual-world/episodes/Embedded-Rust--Ferrous-Systems---James-Munns-eidv76)
* [audio] [Rust GameDev Podcast - Interview with Herbert Wolverson (Bracket-Lib)](https://rustgamedev.com/episodes/interview-with-herbert-wolverson-bracket-lib)
* [video] [Before Main: How Executables Work on Linux](https://youtu.be/jR2hUhjcAXI)
* [video] [RustConf 2020 - Opening Keynote](https://youtu.be/IwPRu5FhfIQ)
* [video] [RustConf 2020 - How to Start a Solo Project that You'll Stick With](https://youtu.be/yv6L_xmjw5I)
* [video] [RustConf 2020 - Closing Keynote](https://youtu.be/RNsEsZbXE-4)

Number: 354  Date: 2020-09-04 

### Official
* [Announcing Rust 1.46.0](https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.html)
### Tooling
* [Rust Analyzer Changelog #40](https://rust-analyzer.github.io/thisweek/2020/08/31/changelog-40.html)
* [Contributing to the IntelliJ Rust plugin: Writing an intention](https://kobzol.github.io/rust/intellij/2020/08/25/contributing-2-subst-assoc-type-int.html)
### Newsletters
* [Rust in Blockchain Newsletter #15 - Turbofish in the Blocksea](https://rustinblockchain.org/newsletters/2020-09-02-turbofish-in-the-blocksea/)
### Observations/Thoughts
* [Should we trust Rust with the future of systems programming?](https://edfloreshz.blog/should-we-trust-rust-with-the-future-of-systems-programming)
* [Optionality in the type systems of Julia and Rust](https://andreaskroepelin.de/blog/sum_types/)
* [Migrating from quick-error to SNAFU: a story on revamped error handling in Rust](https://dev.to/e_net4/migrating-from-quick-error-to-snafu-a-story-on-revamped-error-handling-in-rust-58h9)
* [Go use those Traits](https://prateeknischal.github.io/go-use-those-traits/)
* [Starframe devlog: Architecture](https://moletrooper.github.io/blog/2020/08/starframe-1-architecture/)
* [Event Chaining as a Decoupling Method in Entity-Component-System](https://www.jojolepro.com/blog/2020-08-20_event_chaining/)
* [Rust serialization: What's ready for production today?](https://blog.logrocket.com/rust-serialization-whats-ready-for-production-today/)
* [rust vs scripted languages; a short case study](https://www.linkedin.com/pulse/rust-goodness-case-study-matthew-sherborne)
* [DE] [Entwicklung: Warum Rust die Antwort auf miese Software und Programmierfehler ist](https://www.heise.de/hintergrund/Entwicklung-Warum-Rust-die-Antwort-auf-miese-Software-und-Programmierfehler-ist-4879795.html)
* [video] [Is Rust Used Safely by Software Developers?](https://youtu.be/iOBXVOAbpdY)
### Learn Standard Rust
* [Ownership in Rust, Part 1](https://www.thomascountz.com/2018/07/09/ownership-in-rust-part-1)
* [Ownership in Rust, Part 2](https://www.thomascountz.com/2018/07/11/ownership-in-rust-part-2)
* [Learning Rust 1: Install things and read a file](https://dev.to/jbachhardie/learning-rust-1-install-things-and-read-a-file-5613)
* [Learning Rust 2: A Tiny Database is Born](https://dev.to/jbachhardie/learning-rust-2-a-tiny-database-is-born-eef)
* [That's so Rusty: Ownership](https://dev.to/imaculate3/that-s-so-rusty-ownership-493c)
### Learn More Rust
* [As above, so below: Bare metal Rust generics 2/2](https://www.ecorax.net/as-above-so-below-2/)
* [Halite III Bot Development Kit in Rust](https://sgolem.com/halite-iii-bot-development-kit-in-rust)
* [Zero To Production #3.5: HTML forms, Databases, Integration tests](https://www.lpalmieri.com/posts/2020-08-31-zero-to-production-3-5-html-forms-databases-integration-tests/)
* [Objective-Rust](https://belkadan.com/blog/2020/08/Objective-Rust/)
* [Building web apps with Rust using the Rocket framework](https://blog.logrocket.com/rust-web-apps-using-rocket-framework/)
* [Writing an asynchronous MQTT Broker in Rust - Part 3](https://hassamuddin.com/blog/rust-mqtt/channels/)
* [Multiple Thread Pools in Rust](https://pkolaczk.github.io/multiple-threadpools-rust/)
* [Type-directed metaprogramming in Rust](https://willcrichton.net/notes/type-directed-metaprogramming-in-rust/)
* [Generating static arrays during compile time in Rust](https://dev.to/rustyoctopus/generating-static-arrays-during-compile-time-in-rust-10d8)
* [Let's build a single binary gRPC server-client with Rust in 2020 - Part 2](https://dev.to/tjtelan/let-s-build-a-single-binary-grpc-server-client-with-rust-in-2020-part-2-1i2e)
* [How to use Rust + WebAssembly to Perform Serverless Machine Learning and Data Visualization in the Cloud](https://www.freecodecamp.org/news/rust-webassembly-serverless-tencent-cloud/)
* [Fireworks for your terminal](https://blog.darrien.dev/posts/fireworks-for-your-terminal/)
* [Serverless Data Ingestion with Rust and AWS SES](http://jamesmcm.github.io/blog/2020/08/29/rust-ses/#en)
* [Box Plots at the Olympics](https://datacrayon.com/posts/programming/rust-notebooks/box-plots-at-the-olympics/)
* [Fixing include_bytes!](https://jack.wrenn.fyi/blog/include-transmute/)
* [Generating static arrays during compile time in Rust](https://dev.to/rustyoctopus/generating-static-arrays-during-compile-time-in-rust-10d8)
* [PL] [CrabbyBird #1 O tym, jak animować postać gracza](https://postacnormalna.pl/animacja-kraboptaka/)
* [video] [FLTK Rust: Creating a music player with customized widgets](https://youtu.be/okdFx6tv7ds)
### Project Updates
* [This August in my database project written in Rust](https://alex-dukhno.github.io/2020-08-29-This-August-in-my-Database-project-written-in-rust-copy/)
* [Using Rust for Kentik's New Synthetic Monitoring Agent](https://www.kentik.com/blog/using-rust-for-kentiks-new-synthetic-network-monitoring-agent/)
* [AWS introduces Bottlerocket: A Rust language-oriented Linux for containers](https://www.zdnet.com/article/aws-introduces-bottlerocket-a-rust-language-oriented-linux-for-containers/)
* [Using `cargo test` for embedded testing with `panic-probe`](https://ferrous-systems.com/blog/cargo-test-with-panic-probe/)
* [Headcrab: August 2020 progress report](https://headcrab.rs/2020/08/31/august-update.html)
* [Rust Analyzer 2020[..6] Financial Report](https://rust-analyzer.github.io/blog/2020/08/20/financial-report.html)
### Miscellaneous
* [Avoid Build Cache Bloat By Sweeping Away Artifacts](https://www.justanotherdot.com/posts/avoid-build-cache-bloat-by-sweeping-away-artifacts.html)
* [const_fn makes it too easy to do mandelbrots](https://www.reddit.com/r/rust/comments/ijpxz2/const_fn_makes_it_too_easy_to_do_mandelbrots/)
* [Linux Developers Continue Evaluating The Path To Adding Rust Code To The Kernel](https://www.phoronix.com/scan.php?page=news_item&px=Linux-Kernel-Rust-Path-LPC2020)
* [Supporting Linux kernel development in Rust](https://lwn.net/SubscriberLink/829858/281103f9c6fd0dc2/)
* [video] [LPC 2020 - LLVM MC](https://youtu.be/FFjV9f_Ub9o)
* [Serverless Data Ingestion with Rust and AWS SES](http://jamesmcm.github.io/blog/2020/08/29/rust-ses/#en)
* [Refactoring Rust Transpiled from C](https://immunant.com/blog/2020/09/transpiled_c_safety/)

Number: 355  Date: 2020-09-09 

### Official
* [Planning the 2021 Roadmap](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html)
### Tooling
* [Rust Analyzer Changelog #41](https://rust-analyzer.github.io/thisweek/2020/09/07/changelog-41.html)
* [IntelliJ Rust Changelog #130](https://intellij-rust.github.io/2020/09/07/changelog-130.html)
### Newsletters
* [This Month in Rust GameDev #13 - August 2020](https://rust-gamedev.github.io/posts/newsletter-013/)
* [This Month in Rust OSDev (August 2020)](https://rust-osdev.com/this-month/2020-08/)
### Observations/Thoughts
* [Retrospective of my first useful Rust project](http://jamesmcm.github.io/blog/2020/09/05/vopono/#en)
### Learn Standard Rust
* [TR] [Rust Turu](https://tourofrust.com/00_tr.html)
* [A half-hour to learn Rust](https://fasterthanli.me/articles/a-half-hour-to-learn-rust)
* [Rust - understanding traits 1](https://dev.to/brunooliveira/rust-understanding-traits-1-45md)
* [That's so Rusty: Mutables](https://dev.to/imaculate3/that-s-so-rusty-mutables-5b40)
* [video] [Choosing Rust - Intro to Rust and Ownership](https://www.youtube.com/watch?v=DMAnfOlhSpU)
### Learn More Rust
* [Linux System Call `fork()` in Rust ](https://blog.knoldus.com/linux-system-call-fork-in-rust/)
* [Peeking inside a Rust enum](https://fasterthanli.me/articles/peeking-inside-a-rust-enum)
* [How to speed up the Rust compiler one last time](https://blog.mozilla.org/nnethercote/2020/09/08/how-to-speed-up-the-rust-compiler-one-last-time/)
* [Rust on Haiku: the Case of the Disappearing Deceased Threads](https://www.haiku-os.org/blog/nielx/2020-09-06_rust_on_haiku_the_case_of_the_disappearing_deceased_threads/)
* [C++ vs Rust: an async Thread-per-Core story](https://medium.com/@glaubercosta_11125/c-vs-rust-an-async-thread-per-core-story-28c4b43c410c)
* [Twistrs - Domain name enumeration library in Rust](https://blog.digital-horror.com/twistrs/)
* [If you want performance, cheat!](https://vorner.github.io/2020/09/03/performance-cheating.html)
* [Deserializing JSON really fast](https://blog.datalust.co/deserializing-json-really-fast/)
* [Intercepting Zoom's encrypted data with BPF](https://confused.ai/posts/intercepting-zoom-tls-encryption-bpf-uprobes)
  - **DISCLAIMER**: This article uses methods that could be used illegally in many areas worldwide. Please do not use such methods illegally. The This Week in Rust team and the Rust project leadership are not responsible for any illegal activity by readers.
* [Make A Language - Part Zero: Getting set up](https://arzg.github.io/lang/0)
* [Make A Language - Part One: A basic parser](https://arzg.github.io/lang/1)
* [Make A Language - Part Two: Whitespace support](https://arzg.github.io/lang/2)
* [Let's build a singl binary gRPC server-client with Rust in 2020 - Part 3](https://dev.to/tjtelan/let-s-build-a-single-binary-grpc-server-client-with-rust-in-2020-part-3-3fo8)
* [My Adventures in MMIO Abstraction](https://gist.github.com/Measter/2108508ba25ebe3978a6c10a1e01b9ad)
* [I C and .so does Rust](https://prateeknischal.github.io/i-c-and-so-does-rust/)
* [HTTP Status Codes With Rust](https://www.fpcomplete.com/blog/http-status-codes-async-rust/)
* [PL] [CrabbyBird #2 Poruszanie kamerą](https://postacnormalna.pl/ruch-kamery/)
* [video] [Using rust jni to call an external rust library in java](https://youtu.be/VIZK14pnGcw)
* [video] [1 - Basic Actix Web Server](https://youtu.be/HO-KMVXvXdA)
* [video] [2 - Creating the Tables](https://youtu.be/p22KFotfMYg)
* [video] [3 - Working with the Database](https://youtu.be/tK7qt0igtZA)
* [video] [4 - Getting the links](https://youtu.be/lxBxeKOZu3w)
### Project Updates
* [Rust testing or verifying: Why not both?](https://alastairreid.github.io/why-not-both/)
* [Learning Embedded Rust with Knurling-rs](https://ferrous-systems.com/blog/knurling-sessions-introduction/)
### Miscellaneous
* [Create an amazing Rust GitHub project in no time](https://www.marcoieni.com/2020/09/create-an-amazing-rust-github-project-in-no-time/)
* [Leaving the Rust core team](https://www.ncameron.org/blog/leaving-the-rust-core-team/)
* [Threadripper meets rustc](https://bobweb.co/article/threadripper-meets-rustc)
* [Understanding and Evolving the Rust Programming Language](https://people.mpi-sws.org/~jung/thesis.html)
* [Path Trimming in Nightly Rust](https://blog.aloni.org/posts/path-trimming-in-rust-nightly/)
* [Steve Klabnik Interview - "Rust isn't afraid to be imperfect as long as we ship something useful"](https://evrone.com/steve-klabnik-interview)
* [On finally learning to program at the age of 40](https://github.com/Dhghomon/programming_at_40/blob/master/README.md)
* [video] [Iota Identity-Diff Macro - Live Stream](https://youtu.be/1r094Uzz7A0)

Number: 356  Date: 2020-09-16 

No newsletters this week.
### Official
* [Launching the 2020 State of Rust Survey](https://blog.rust-lang.org/2020/09/10/survey-launch.html)
* [A call for contributors from the WG-prioritization team](https://blog.rust-lang.org/2020/09/14/wg-prio-call-for-contributors.html)
### Tooling
* [Rust Analyzer Changelog #42](https://rust-analyzer.github.io/thisweek/2020/09/14/changelog-42.html)
### Observations/Thoughts
* [Which Parsing Approach?](https://tratt.net/laurie/blog/entries/which_parsing_approach.html)
* [Challenging LR Parsing](https://rust-analyzer.github.io//blog/2020/09/16/challeging-LR-parsing.html)
* [What I Learnt from Benchmarking Http4k, Ktor (Kotlin) and Actix v2, v3 (Rust) Microservices](https://matej.laitl.cz/bench-rust-kotlin-microservices/)
* [No Namespaces in Rust is a Feature](https://samsieber.tech/posts/2020/09/registry-structure-influence/)
* [Building devserver: An Ultra-Tiny Rust Server](https://ianjk.com/devserver/)
* [Taming nalgebra's Rustdoc](https://jack.wrenn.fyi/blog/rustdocing-nalgebra/)
* [Rust in Science and ever-changing requirements](https://amanjeev.com/blog/rust-in-science-and-ever-changing-requirements)
* [From @Test to #[test]: an essay about testing between Java and Rust](https://mateuscosta.me/testing-between-java-and-rust)
### Learn Standard Rust
* [Collecting Data from an API](https://davidmaceachern.com/posts/collecting-data-from-an-api)
* [SQLite File Parser Pt. 1: The Header](https://wiredforge.com/blog/sqlite-parser-pt-1/index.html)
* [An introduction to Data Oriented Design with Rust](https://jamesmcm.github.io/blog/2020/07/25/intro-dod/)
* [Rust for Java developers](https://blog.codecentric.de/en/2020/09/rust-for-java-developers/)
* [Oxidizing portals with zbus](https://belmoussaoui.com/article/13-oxidizing-portals)
### Learn More Rust
* [Implementing Records in x7](https://dpbriggs.ca/blog/Implementing-Method-Calls-In-x7)
* [Let's build a single binary gRPC server-client with Rust in 2020 - Part 4](https://dev.to/tjtelan/let-s-build-a-single-binary-grpc-server-client-with-rust-in-2020-part-4-3k9f)
* [Make A Language - Part Three: Defining variables](https://arzg.github.io/lang/3/)
* [Rust HTTP Testing with httpmock](https://alexliesenfeld.com/posts/2020/rust-http-testing-with-httpmock/)
### Project Updates
* [Announcing the CCS811 indoor air quality sensor driver](https://blog.eldruin.com/ccs811-indoor-air-quality-sensor-driver-in-rust/).
* [OpenPGP in Rust: the Sequoia project](https://lwn.net/SubscriberLink/830902/b751810a99460a39/)
* [AssemblyLift v0.2 preview: RPC-based IO modules](https://dev.to/dotxlem/assemblylift-v0-2-preview-rpc-based-io-modules-2d38)
* [Announcing Actix Web v3.0](https://paper.dropbox.com/published/Announcing-Actix-Web-v3.0-QOXXb1lXgTubzXHzUq9ONY5)
### Miscellaneous
* [Your Language Sucks, It Doesn't Matter](https://matklad.github.io//2020/09/13/your-language-sucks.html)
* [Rust is #18 in the TIOBE Index for September 2020](https://www.tiobe.com/tiobe-index/)
* [A Few Github Action "Recipes" for Rust](https://shift.click/blog/github-actions-rust/)
* [Writing an x86 bootloader in Rust that can launch vmlinux](https://vmm.dev/en/rust/krabs.md)
* [video] [GOTO 2020 - Next-Generation Programming: Rust & Elm - Richard Feldman](https://youtu.be/ukVqQGbxM9A)
# Call for Blog Posts
The Rust Core Team wants input from the community!
If you haven't already, [read the official blog](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html) and submit a blog post - it will show up here!
Here are the wonderful submissions since the call for blog posts:
* [Rust in 2021](https://matklad.github.io/2020/09/12/rust-in-2021.html)
* [Rust 2021](https://hsivonen.fi/rust2021/)

Number: 357  Date: 2020-09-23 

No newsletters this week.
### Official
* [Call for 2021 Roadmap Blogs Ending Soon](https://blog.rust-lang.org/2020/09/21/Scheduling-2021-Roadmap.html)
* [Announcing the Error Handling Project Group](https://blog.rust-lang.org/inside-rust/2020/09/18/error-handling-wg-announcement.html)
* [Inside] [Intra-doc links close to stabilization](https://blog.rust-lang.org/inside-rust/2020/09/17/stabilizing-intra-doc-links.html)
### Tooling
* [IntelliJ Rust Changelog #131](https://intellij-rust.github.io/2020/09/21/changelog-131.html)
* [Rust Analyzer Changelog #43](https://rust-analyzer.github.io/thisweek/2020/09/21/changelog-43.html)
* [Knurling-rs Changelog #1](https://ferrous-systems.com/blog/knurling-changelog-1/)
### Observations/Thoughts
* [Porting EBU R128 audio loudness analysis from C to Rust](https://coaxion.net/blog/2020/09/porting-ebu-r128-audio-loudness-analysis-from-c-to-rust/)
* [Types Over Strings: Extensible Architectures in Rust](https://willcrichton.net/notes/types-over-strings/)
* [Why Not Rust?](https://matklad.github.io//2020/09/20/why-not-rust.html)
* [Why not rust for security?](https://www.cryptologie.net/article/505/why-not-rust-for-security/)
* [Why Rust is not a mature programming language](https://codecs.multimedia.cx/2020/09/why-rust-is-not-a-mature-programming-language/)
* [My Favorite Rust Signature](https://www.brandonsmith.ninja/blog/favorite-rust-function)
* [Is Rust a Functional Language in Disguise?](https://ceronman.com/2020/09/17/is-rust-a-functional-language-in-disguise/)
* [Async Iteration Semantics](https://blog.yoshuawuyts.com/async-iteration/)
* [A New Backend for Cranelift, Part 1: Instruction Selection](https://cfallin.org/blog/2020/09/18/cranelift-isel-1/)
* [Throw-away code](https://vorner.github.io/2020/09/20/throw-away-code.html)
* [I started to learn Rust](https://jean.manguy.eu/post/i-started-to-learn-rust/)
* [Pure AST based linting sucks](https://rdambrosio016.github.io/rust/2020/09/18/pure-ast-based-linting-sucks.html)
* [Potential improvements for Rust embedded abstractions](https://tweedegolf.nl/blog/42/potential-improvements-for-rust-embedded-abstractions)
### Learn Standard Rust
* [TL;DR Rust](https://christine.website/blog/TLDR-rust-2020-09-19)
* [Variables And Mutability In Rust](https://edfloreshz.blog/variables-and-mutability)
* [Rust For Beginners Workshop Track](https://rustlabs.kubedaily.com/Beginners/README.html)
* [Learning Rust: OMG WTF RS – resources to help you get started with Rust](https://ferrous-systems.com/blog/omg-wtf-rs-resources-to-help-you-get-started-with-rust/)
* [Write your own Rust compiler plugin in only 10 lines!](https://dev.to/sam3d/write-your-own-rust-compiler-plugin-in-only-10-lines-4df4)
* [Optional arguments in Rust](https://dev.to/virtualkirill/optional-arguments-in-rust-1e9g)
* [Implementation of Binary Search Tree in Rust](https://medium.com/@bkuliyev/implementation-of-binary-search-tree-in-rust-ce7ce479b505)
* [FR] [Le concept de “propriétaire” ou “ownership” en Rust](https://medium.com/@nunes.nelson4/le-concept-de-propri%C3%A9taire-ou-ownership-en-rust-c96d43c3375d)
* [TH] [Rustler 101: Ferris Say](https://dev.to/wingyplus/rustler-101-ferris-say-3jj6)
### Learn More Rust
* [Dynamic Iterators](https://hole.tuziwo.info/dyn-iterator.html)
* [Low-Level Academy](https://lowlvl.org/)
* [Writing an HTTP(S) Tunnel in Rust with tokio.](https://medium.com/@xnuter/writing-a-modern-http-s-tunnel-in-rust-56e70d898700)
* [Down the Yak Hole of TLS](https://blog.drogue.io/yak-hole-of-tls/)
* [That's so Rusty: Metaprogramming](https://dev.to/imaculate3/that-s-so-rusty-metaprogramming-49mj)
* [The Bevy Game Engine #1](https://dev.to/ethanyidong/the-bevy-engine-1-4k4k)
* [Face Detection in Node.js with Rust and WebAssembly](https://dev.to/alabulei1/high-performance-and-safe-ai-as-a-service-in-node-js-43lg)
* [video] [FLTK Rust: Using FLTK on Android](https://youtu.be/3jW_vxGmxt0)
### Project Updates
* [Announcing and Unpacking the New Holochain](https://medium.com/holochain/unpacking-the-new-holochain-f54da3ca99b7)
### Miscellaneous
* [Extended CfP deadline & new speaker perks!](https://blog.rustfest.eu/cfp-extension-new-speaker-perks)
* [Neovim and Rust](https://sharksforarms.dev/posts/neovim-rust/)
* [How I stopped worrying and started coding in Rust 🦀️](https://dev.to/yjdoc2/how-i-stopped-worrying-and-started-coding-in-rust-52b)
* [Haskell's Children](https://owenlynch.org/posts/2020-09-16-haskells-children/)
* [A Bazel Persistent Worker for Rust](https://nikhilism.com/post/2020/bazel-persistent-worker-rust/)
* [ESXi Binaries with Rust](https://sbaronda.com/2020/09/20/esxi-binaries-with-rust/)
* [j4rs: JavaFX support (WIP)](https://astonbitecode.github.io/blog/post/j4rs_javafx_support/)
* [Porting PineTime Watch Face from C to Rust On RIOT with LVGL](https://lupyuen.github.io/pinetime-rust-riot/articles/watch_face)
* [JP] [Rustのasyncでgoroutineの速度に勝つ](https://medium.com/nttlabs/rust-async-runtime-877b516d934d)
# Call for Blog Posts
The Rust Core Team wants input from the community!
If you haven't already, [read the official blog](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html) and submit a blog post - it will show up here!
Here are the wonderful submissions since the call for blog posts:
* [Rust 2021 - Ethical Development](https://llogiq.github.io/2020/09/21/ethics.html)
* [My Rust 2021 Wishlist for the 2021 Roadmap](https://estada.ch/2020/9/23/my-rust-2021-wishlist-for-the-2021-roadmap/)
* [Rust 2021: Lower the barriers](https://blog.nindalf.com/posts/rust-2021/)
* [Request for a better [patch] in cargo](https://longfangsong.github.io/2020/09/07/Rust-2021-Request-for-a-better-patch-in-cargo/)
* [What I wish for #Rust2021](https://haurchefant.fr/posts/what-i-wish-for-rust2021/)
* [Rust in 2021](https://www.ncameron.org/blog/rust-in-2021/)
* [Rust 2021](https://gist.github.com/mark-i-m/57b51099e02f2d1fb4d4a4bf08e92965)
* [As a hobbyist rust developer, I want to think less about error handling](https://mbuffett.com/posts/rust-less-error-handling/)
* [Rust 2021](https://gist.github.com/pickfire/3bcceeacf0bae22dd9f03c5053a976e3)
* [My Least Favorite Rust Type](https://ridiculousfish.com/blog/posts/least-favorite-rust-type.html)
* [My wish list for Rust 2021](https://sam-vente.com/blog/my-rust-2021-wishlist/index.html)
* [My Rust 2021 roadmap](https://www.reddit.com/r/rust/comments/imd8b8/my_rust_2021_roadmap/)
* [Rust Roadmap 2021: Allowing for arbitrary size integer primitives](https://therealprof.github.io/blog/roadmap-2021-arbitrary-size-primitives/)
* [Rust Roadmap 2021: Adding a useful dev mode and making it the default](https://therealprof.github.io/blog/roadmap-2021-usable-dev-mode/)
* [Rust in 2021](https://jyn514.github.io/2020/09/05/Rust-in-2021.html)
* [What's Stopping Me From Using Rust?](https://mgrech.dev/whats-stopping-me-from-using-rust/)
* [Pastebin submission](https://pastebin.com/d6jaxh7n)
* [Hacker News submission](https://news.ycombinator.com/item?id=24368077)

Number: 358  Date: 2020-09-30 

No newsletters this week.
### Official
* [Inside] [Announcing the Portable SIMD Project Group](https://blog.rust-lang.org/inside-rust/2020/09/29/Portable-SIMD-PG.html)
### Tooling
* [Rust Analyzer Changelog #44](https://rust-analyzer.github.io/thisweek/2020/09/28/changelog-44.html)
* [Knurling-rs Changelog #2](https://ferrous-systems.com/blog/knurling-changelog-2/)
### Observations/Thoughts
* [Benchmarking vol. 2: Pitting Actix against Rocket v0.4 and v0.5-dev](https://matej.laitl.cz/bench-actix-rocket/)
* [Optimization - Making Rust Code Go Brrrr](https://aspenuwu.me/posts/rust-optimization.html)
* [Revisiting a 'smaller Rust'](https://without.boats/blog/revisiting-a-smaller-rust/)
* [A Future for Rust Debugging](https://nbaksalyar.github.io/2020/05/19/rust-debug.html)
* [Learning Rust the Open Source Way](https://bitsbybrad.com/2020-09-29-learning-rust/)
* [So you want to live-reload Rust](https://fasterthanli.me/articles/so-you-want-to-live-reload-rust)
* [Drop order in Rust: It's tricky](https://vojtechkral.github.io/blag/rust-drop-order/)
### Learn Simple Rust
* [What’s new in Rust 1.46.0 about const_fn?](https://blog.knoldus.com/whats-new-in-rust-1-46-0/)
* [Rust: expression vs statement](https://dev.to/nickymeuleman/rust-expression-vs-statement-2h7g)
* [To Box or not to Box -- My First Real Rust Refactor](https://medium.com/@KevinHoffman/to-box-or-not-to-box-my-first-real-rust-refactor-db467119c4c7)
* [Bevy #2: Space Shooter - The Player](https://dev.to/ethanyidong/bevy-2-space-shooter-the-player-3e7d)
* [Cucumber in Rust - Beginner's Tutorial](https://www.florianreinhard.de/2020-08-16/cucumber-in-rust-beginners-tutorial/)
* [Data Types in Rust](https://edfloreshz.blog/data-types-in-rust)
* [video] [Rust 101](https://www.youtube.com/watch?v=wNzXj4eddDo&feature=youtu.be)
### Learn More Rust
* [Are we observable yet? An introduction to Rust telemetry - Zero To Production #4](https://www.lpalmieri.com/posts/2020-09-27-zero-to-production-4-are-we-observable-yet/)
* [A Fistful of States: More State Machine Patterns in Rust](https://deislabs.io/posts/a-fistful-of-states/)
* [OS in Rust: An executable that runs on bare metal: Part-1](https://blog.knoldus.com/os-in-rust-an-executable-that-runs-on-bare-metal-part-1/)
* [OS in Rust: An executable that runs on bare metal: Part-2](https://blog.knoldus.com/os-in-rust-an-executable-that-runs-on-bare-metal-part-2/)
* [Build a Discord Bot with Rust and Serenity](https://developers.facebook.com/blog/post/2020/09/30/build-discord-bot-with-rust-and-serenity/)
* [Porting EBU R128 audio loudness analysis from C to Rust – Porting Details](https://coaxion.net/blog/2020/09/porting-ebu-r128-audio-loudness-analysis-from-c-to-rust-porting-details/)
* [Building a runtime reflection system for Rust 🦀️ (Part 1)](https://www.osohq.com/post/rust-reflection-pt-1)
* [Rusty-PID: Porting the TSic sensor from C to Rust](https://nitschinger.at/Rusty-PID-Porting-the-TSic-sensor-from-C-to-Rust/)
* [Playing Codenames in Rust with word vectors](https://rolisz.ro/2020/09/26/playing-codenames-in-rust-with-word-vectors/)
* [Type-level Programming in Rust](https://willcrichton.net/notes/type-level-programming/)
* [Multi-threading with Wgpu and Rayon](https://sotrh.github.io/learn-wgpu/intermediate/tutorial13-threading/#threading-build-rs)
* [Flicker free fireworks (or how I accidentally rediscovered the regen buffer)](https://blog.darrien.dev/posts/flicker-free-fireworks/)
* [audio] [The Rustacean Station Podcast - WebAssembly on the Server with Krustlet](https://rustacean-station.org/episode/030-krustlet/)
* [video] [RIOT Summit 2020 - Safer & Simpler Embedded Programs with Rust on RIOT](https://www.youtube.com/watch?v=LvfCSnOM1Hs&feature=youtu.be)
* [video] [One Day Build - Anachro SPI pt 2](https://www.youtube.com/watch?time_continue=69&v=2vk9H9-O_pI&feature=emb_logo)
* [video] [Rusty USB Gadgets Make Barking BeagleBones](https://www.youtube.com/watch?v=NgdWeR1CvI8&feature=emb_logo)
### Project Updates
* [Krustlet v0.5.0 Release](https://github.com/deislabs/krustlet/releases/tag/v0.5.0)
* [oso, an open-source policy engine for authorization written in Rust](https://github.com/osohq/oso), added [a Rust library for implementing authorization for Rust projects!](https://docs.rs/oso/0.6.0-alpha/oso/)
* [Rust on the ESP32 & ESP8266 - Building an ecosystem](https://mabez.dev/blog/posts/esp-rust-ecosystem/)
* [What (not so) recently happened in Miri](https://www.ralfj.de/blog/2020/09/28/miri.html)
* [Progress report on rustc_codegen_cranelift (Sep 2020)](https://bjorn3.github.io/2020/09/28/progress-report-sep-2020.html)
### Miscellaneous
* [Supercharge your Electron apps with Rust](https://blog.logrocket.com/supercharge-your-electron-apps-with-rust/)
* [How to Make a 💡?](https://rust-analyzer.github.io/blog/2020/09/28/how-to-make-a-light-bulb.html)
* [Towards principled reactive UI](https://raphlinus.github.io/rust/druid/2020/09/25/principled-reactive-ui.html)
* [Building even faster interpreters in Rust](https://blog.cloudflare.com/building-even-faster-interpreters-in-rust/)
* [AMD Is Hiring To Work On New Radeon Driver Tooling Written In Rust](https://www.phoronix.com/scan.php?page=news_item&px=AMD-Hiring-Radeon-Rust)
* [Rust programming language exploit mitigations](https://rcvalle.blog/2020/09/16/rust-lang-exploit-mitigations/)
* [Custom Literals in Rust](https://www.5snb.club/posts/2020/09/25/custom-literals-in-rust.html)
# Call for Blog Posts
The Rust Core Team wants input from the community!
If you haven't already, [read the official blog](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html) and submit a blog post - it will show up here!
Here are the wonderful submissions since the call for blog posts:
* [Rust 2021: GUI](https://raphlinus.github.io/rust/druid/2020/09/28/rust-2021.html)
* [Rust 2021: maintain dominance on the web, easy funding, easier learning](https://www.reddit.com/r/rust/comments/j1ihax/rust_2021_maintain_dominance_on_the_web_easy/)
* [Rust 2021: Easier to integrate into existing codebases](https://www.reddit.com/r/rust/comments/j06zc9/rust_2021_easier_to_integrate_into_existing/)
* [Rust 2021: Continue](https://www.reddit.com/r/rust/comments/izk75l/rust_2021_continue/)
* [Rust 2021 | Features and Trait Bounds in Macros](https://blog.carminecrystal.com/rust-2021-features-and-trait-bounds-in-macros.html)
* [Rust 2021: Quality, frictionless tooling](https://swatinem.de/blog/rust-2021/)
* [My Rust 2021 roadmap: crates, concision, and community](http://jamesmcm.github.io/blog/2020/09/24/rust2021/#en)
* [Rust 2021 Roadmap Wishlist](https://aldaronlau.com/rust-2021/)
* [Rust in 2021: We've done a lot, more to be done](https://popzxc.github.io/rust-2021)
* [Rust in 2021: Leveraging the Type System for Infallible Message Buffers](https://christian.amsuess.com/blog/website/2020-09-24_rust_2021/)
* [Rust 2021](https://blog.coderspirit.xyz/blog/2020/09/26/rust-2021/)
* [Rust 2021: Minor major improvements](https://blog.thomasheartman.com/posts/rust-2021)
* [Rust 2021](https://beyermatthias.de/blog/2020/09/28/rust-2021/)
* [My Rust 2021](https://blog-dry.com/entry/2020/09/29/135738)

Number: 359  Date: 2020-10-07 

### Official
* [Inside] [1.47.0 pre-release testing](https://blog.rust-lang.org/inside-rust/2020/10/06/1.47.0-prerelease.html)
* [Inside] [1.47.0 second pre-release testing](https://blog.rust-lang.org/inside-rust/2020/10/06/1.47.0-prerelease.html)
### Newsletters
* [This Month in Rust OSDev (September 2020)](https://rust-osdev.com/this-month/2020-09/)
* [Rust in Blockchain Newsletter #16 - Secure Enclaves à la Crab](https://rustinblockchain.org/newsletters/2020-09-30-secure-enclaves-a-la-crab/)
* [This Month in Dimforge #1 (October 2020)](https://www.dimforge.com/blog/2020/10/01/this-month-in-dimforge/)
### Tooling
* [Rust Analyzer Changelog #45](https://rust-analyzer.github.io/thisweek/2020/10/05/changelog-45.html)
* [IntelliJ Rust Changelog #132](https://intellij-rust.github.io/2020/10/05/changelog-132.html)
### Observations/Thoughts
* [Why I scatter `use` statements throughout Rust code](https://tarquin-the-brave.github.io/blog/posts/rust_use_statements/)
* [Rust + Raspberry Pi Tide Clock](https://thefuntastic.com/blog/rust-tide-clock)
* [You're Allowed To Write Slow Rust Code](https://blog.jonstodle.com/youre-allowed-to-write-slow-rust-code/)
* [Rust meets the web - a clash of programming paradigms](https://www.jakobmeier.ch/blogging/Rust_on_the_Web.html)
* [Dynamic widget sketches](https://www.cmyr.net/blog/druid-dynamism.html)
* [Results of Authoring a JS Library with Rust and Wasm](https://nickb.dev/blog/results-of-authoring-a-js-library-with-rust-and-wasm)
* [Ringbahn III: A deeper dive into drivers](https://without.boats/blog/ringbahn-iii/)
* [Fast Thread Locals In Rust](https://matklad.github.io/2020/10/03/fast-thread-locals-in-rust.html)
* [Formicarium](https://gliderkite.github.io/posts/formicarium/)
### Learn Simple Rust
* [Dancing Links In Rust](https://ferrous-systems.com/blog/dlx-in-rust/)
* [Getting Started with the nRF52840 in Rust](https://nitschinger.at/Getting-Started-with-the-nRF52840-in-Rust/)
* [That's so Rust!: Smart pointers](https://dev.to/imaculate3/that-s-so-rusty-smart-pointers-245l)
* [video] [Test-Based and Graphical User Interfaces | Rust Project](https://youtu.be/dK9-oXptFcM)
### Learn More Rust
* [8 Solutions for Troubleshooting Your Rust Build Times](https://medium.com/@jondot/8-steps-for-troubleshooting-your-rust-build-times-2ffc965fd13e)
* [Benchmarking Apache Cassandra with Rust](https://pkolaczk.github.io/benchmarking-cassandra/)
* [Operating System development tutorials in Rust on the Raspberry Pi](https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials)
* [Learning Embedded Rust with Knurling-rs](https://ferrous-systems.com/blog/knurling-sessions-introduction/)
* [Building a Weater Station Bot](https://blog.kdubovikov.ml/articles/rust/building-a-weather-station-bot)
* [Next-Gen Rust Web Apps: Towards a Svelte Fulcro in Rust](https://blog.shortepic.com/blog/first/)
* [Next-Gen Rust Web Apps: TicTacToe in Valerie](https://blog.shortepic.com/blog/second/)
* [Next-Gen Rust Web Apps: Borrowing From Fulcro for your Rust WASM Spa](https://blog.shortepic.com/blog/third/)
* [Make A Language - Part Four: Backtracking](https://arzg.github.io/lang/4/)
* [Make A Language - Part Five: Binding Usages](https://arzg.github.io/lang/5/)
* [Make A Language - Part Six: Blocks](https://arzg.github.io/lang/6/)
* [Make A Language - Part Seven: A REPL](https://arzg.github.io/lang/7/)
* [audio] [What we've learned porting our apps to Windows - Astropad](https://astropad.com/what-weve-learned-porting-our-apps-to-windows/)
* [video] [Build a Discord Bot with Rust and Serenity](https://www.youtube.com/playlist?list=PLzIwronG0sE5lQCPFP69Ukgz4d9dngaSi)
### Project Updates
* [Headcrab: September 2020 progress report](https://headcrab.rs/2020/10/01/september-update.html)
### Miscellaneous
* [/r/rust is partnering with the Rust communities on Discord, Mozilla's Matrix, and Stack Overflow as venues for "IRC-like" real-time chat](https://www.reddit.com/r/rust/comments/j6b03y/rrust_is_partnering_with_the_rust_communities_on/)
* [[Mesa-dev] Rust drivers in Mesa](https://lists.freedesktop.org/archives/mesa-dev/2020-October/224639.html)
* [Designing a New Rust Class at Stanford: Safety in Systems Programming](https://reberhardt.com/blog/2020/10/05/designing-a-new-class-at-stanford-safety-in-systems-programming.html)
* [Memory Safety Alternative](https://github.com/finegeometer/articles/blob/master/memory-safety-alternative.md)
# Call for Blog Posts
The Rust Core Team wants input from the community!
If you haven't already, [read the official blog](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html) and submit a blog post - it will show up here!
Here are the wonderful submissions since the call for blog posts:
* [Rust 2021: APIs, ORMS and standards](https://medium.com/@v.mishra/rust-2021-apis-orms-and-standards-bfdf3ddc15a0)
* [Rust 2021 - Stability](https://jackh726.github.io/rust/2020/10/01/rust-2021.html)
* [The Rust Organization in 2021](https://tmandry.gitlab.io/blog/posts/rust-2021-organization/)
* [Rust 2021](https://nikhilism.com/post/2020/rust-2021/)
* [Rust 2021: lowering barriers](https://gist.github.com/samsieber/e976664ba333fd8a0b5f3b0ba167cb76#file-rust-2021-md)
* [Rust 2021](https://markentier.tech/posts/2020/10/rust-2021/)
* [The Rust 2021 Experience - Year of the Macro](https://casualhacks.net/blog/2020-10-05/the-rust-2021-experience-macros/)
* [The Rust Project in 2021](https://tmandry.gitlab.io/blog/posts/rust-2021-project/)

Number: 360  Date: 2020-10-14 

### Official
* [Announcing Rust 1.47.0](https://blog.rust-lang.org/2020/10/08/Rust-1.47.html)
### Newsletters
* [This Month in Rust GameDev #14](https://rust-gamedev.github.io/posts/newsletter-014/)
### Tooling
* [Rust Analyzer Changelog #46](https://rust-analyzer.github.io/thisweek/2020/10/12/changelog-46.html)
* [Two videos about rust code coverage in VSCode](https://www.marcoieni.com/2020/10/2-videos-about-rust-code-coverage-in-vscode/)
### Observations/Thoughts
* [Rust after the honeymoon](http://dtrace.org/blogs/bmc/2020/10/11/rust-after-the-honeymoon/)
* [Building the Fastest RaptorQ (RFC6330) Codec in Rust](https://www.cberner.com/2020/10/12/building-fastest-raptorq-rfc6330-codec-rust/)
* [Learning Rust through open source and live code reviews](https://loige.co/learning-rust-through-open-source-and-live-code-reviews/)
* [My Mistakes Making a Canvas Based Game with Rust and WebAssembly](https://dev.to/fallenstedt/making-a-canvas-based-game-with-rust-and-webassembly-2l46)
* [A New Backend for Cranelift, Part 1: Instruction Selection](https://hacks.mozilla.org/2020/10/a-new-backend-for-cranelift-part-1-instruction-selection/)
* [Optional parameters in Rust](https://vidify.org/blog/rust-parameters/)
* [Building an async-compatible actor system](https://github.com/Diggsey/posts/blob/master/actor-systems/README.md)
* [video] [Contract as Code as Contract: Using Rust to Unify Specification and Implementation](https://youtu.be/EmSjZbSzA3A)
### Learn Simple Rust
* [Iterators in Rust](https://blog.thoughtram.io/iterators-in-rust/)
* [Learn Rust by building the game Snake](https://blog.scottlogic.com/2020/10/08/lets-build-snake-with-rust.html)
* [That's so Rusty! Fearless concurrency](https://dev.to/imaculate3/fearless-concurrency-5fk8)
* [Making a Simple Calculator in Rust](https://dev.to/yjdoc2/making-a-simple-calculator-in-rust-d65)
* [Patterns of fallible iteration](https://morestina.net/blog/1607/fallible-iteration)
* [video] [Learn Rust Together Part 5: Structs and Enums!](https://www.youtube.com/watch?v=Iy5pvVPZT50)
* [video] [3. #everyonecancontribute cafe: Gitpod & learning Rust](https://youtu.be/ewDAOLTto-A)
### Learn More Rust
* [Deploying a Rust HTTP server to DigitalOcean App Platform](https://pretired.dazwilkin.com/posts/201008/)
* [Make A Language - Part Eight: Function Definitions](https://arzg.github.io/lang/8/)
* [Supercharge your Electron apps with Rust](https://blog.logrocket.com/supercharge-your-electron-apps-with-rust/)
* [ZH] [Build a Shoot 'em up game with framework Amethyst](https://yodalee.me/2020/06/introduction/)
* [video] [Rust FFI: Microsoft Flight Simulator SDK Part 1](https://youtu.be/jNNz4h3iIlw)
* [video] [Fuzz Testing popular Rust library in 5 min using cargo-fuzz / libfuzzer](https://youtu.be/W0ZRZyljKjo)
### Project Updates
* [Rust in Curl with Hyper](https://daniel.haxx.se/blog/2020/10/09/rust-in-curl-with-hyper/)
* [Memory Safe 'curl' for a More Secure Internet](https://www.abetterinternet.org/post/memory-safe-curl/)
* [Version 0.7 of calloop](https://smithay.github.io/calloop-v-0-7.html)
### Miscellaneous
* [Collect in Rust, Traverse in Haskell and Scala](https://www.fpcomplete.com/blog/collect-rust-traverse-haskell-scala/)
* [Proving that 1 + 1 = 2 in Rust](https://gist.github.com/gretingz/bc194c20a2de2c7bcc0f457282ba2662)
* [What should I program?](http://jamesmcm.github.io/blog/2020/10/11/programming-projects/#en)
* [Getting back to C++ after Rust is a pain.](https://www.reddit.com/r/rust/comments/ja5aoe/getting_back_to_c_after_rust_is_a_pain/)
# Call for Blog Posts
The Rust Core Team wants input from the community!
If you haven't already, [read the official blog](https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.html) and submit a blog post - it will show up here!
Here are the wonderful submissions since the call for blog posts:

Number: 361  Date: 2020-10-21 

No newsletters this week.
### Official
* [Marking issues as regressions](https://blog.rust-lang.org/2020/10/20/regression-labels.html)
* [Inside] [Lang team Backlog Bonanza and Project Proposals](https://blog.rust-lang.org/inside-rust/2020/10/16/Backlog-Bonanza.html)
### Tooling
* [Rust-Analyzer Changelog #47](https://rust-analyzer.github.io/thisweek/2020/10/19/changelog-47.html)
* [IntelliJ Rust Changelog #133](https://intellij-rust.github.io/2020/10/19/changelog-133.html)
### Observations/Thoughts
* [Fearless concurrency: how Clojure, Rust, Pony, Erlang and Dart let you achieve that.](https://sites.google.com/a/athaydes.com/renato-athaydes/posts/fearlessconcurrencyhowclojurerustponyerlanganddartletyouachievethat)
* [Shock Result<>?: Rust faster than Python in one test of file parsing](http://www.coralbark.net/blog/technology/2020/10/shock-result-rust-faster-than-python-in-one-test-of-file-parsing/)
* [Building a Recipe Manager - Part 2 - Druid Experience Report](https://bheisler.github.io/post/recipe-manager-part-2-druid-experience-report/)
* [No, C++ still isn't cutting it.](https://da-data.blogspot.com/2020/10/no-c-still-isnt-cutting-it.html)
* [A pitfall of Rust's move/copy/drop semantics and zeroing data](https://benma.github.io/2020/10/16/rust-zeroize-move.html)
* [Proving that 1 + 1 = 10 in Rust](https://tavianator.com/2020/one_plus_one.html)
* [Study of std::io::Error](https://matklad.github.io/2020/10/15/study-of-std-io-error.html)
* [Fun With Rust's Traits](https://samwho.dev/blog/fun-with-rust-traits/)
### Learn Simple Rust
* [Arrays, vectors and slices in Rust](https://hashrust.com/blog/arrays-vectors-and-slices-in-rust/)
* [Building Your Own Error Type: Part 1](https://yaah.dev/building-your-own-error-type)
* [Lifetimes in Rust](https://blog.thoughtram.io/lifetimes-in-rust/)
* [Piece by Piece: Write Readable Rust Code](https://impl.dev/posts/write-readable-rust-code/)
* [Are out parameters idiomatic in Rust?](https://steveklabnik.com/writing/are-out-parameters-idiomatic-in-rust)
* [Non-Generic Inner Functions](https://www.possiblerust.com/pattern/non-generic-inner-functions)
* [Creating a Snake Clone in Rust, with Bevy](https://mbuffett.com/posts/bevy-snake-tutorial/)
* [Create Your Own PineTime Watch Face in Rust... And Publish on crates.io](https://lupyuen.github.io/pinetime-rust-mynewt/articles/watchface)
* [Either Types for Rust](https://dev.to/sirech/either-types-for-rust-46k4)
* [Rust syntax: What is the questionmark?](https://dev.to/nickymeuleman/rust-syntax-what-the-questionmark-2n58)
* [Private Methods on a Public Trait](https://jack.wrenn.fyi/blog/private-trait-methods/)
* [Learn Rust with Benford's Law](https://gliderkite.github.io/posts/learn-rust-with-benford/)
* [How to Write Hygienic Rust Macros](https://gist.github.com/Koxiaet/8c05ebd4e0e9347eb05f265dfb7252e1)
* [video] [Rust Linz, October 2020 - Valentin Tolmer - How not to rely on inheritance](https://youtu.be/m6Gee5kNe7U)
### Learn More Rust
* [Building a runtime reflection system for Rust 🦀️ (Part 2)](https://www.osohq.com/post/runtime-reflection-pt-2)
* [Compile Rust for Raspberry Pi ARM](https://medium.com/swlh/compiling-rust-for-raspberry-pi-arm-922b55dbb050)
* [Basic non-blocking IO using epoll in Rust](https://zupzup.org/epoll-with-rust/)
* [Debugging async generator errors in Rust](https://meltware.com/2020/10/21/rust-async-nonsense.html)
* [video] [(Live Coding) Audio adventures in Rust: Spotify integration](https://youtu.be/5q4NB9WdYIo)
* [video] [Rust Linz, October 2020 - Matthias Heiden - Writing a Kernel Driver with Rust](https://youtu.be/wREGR7QQHco)
### Project Updates
* [Announcing Tokio 0.3 and the path to 1.0](https://tokio.rs/blog/2020-10-tokio-0-3)
* [oso, an open-source policy engine for authorization written in Rust](https://github.com/osohq/oso), released [version 0.7.0 of their authorization library for Rust projects!](https://docs.rs/oso/0.7.0/oso/)
* ⚡️ [Dotenv-linter v2.2.0: find and fix problems in .env files](https://evrone.com/dotenv-linter-v220)
* [Version 0.3.0 of cargo-wipe has been released](https://github.com/mihai-dinculescu/cargo-wipe)
### Miscellaneous
* [A new look, tickets and what's to come](https://blog.rustfest.eu/a-new-look)
* [ICU4X Project Announcement](https://github.com/unicode-org/icu4x/wiki/ICU4X-Project-Announcement)
* [Kata Containers rewritten in Rust gets a major speed boost](https://www.zdnet.com/article/kata-containers-rewritten-in-rust-and-gets-a-major-speed-boost/)
* [Assorted thoughts on zig (and rust)](https://scattered-thoughts.net/writing/assorted-thoughts-on-zig-and-rust/)
* [Flask Creator Armin Ronacher Interview](https://evrone.com/armin-ronacher-interview)
* [A recipe for start using Rust actix-web and launch chrome 🚀](https://itnext.io/a-recipe-for-starting-actix-web-server-and-launch-chrome-b792987935a)
* [Sailfish OS 3.4 Released with Experimental Rust Support, Finally Eyeing 64-bit ARM](https://www.phoronix.com/scan.php?page=news_item&px=Sailfish-OS-3.4-Released)
* [Create Your Own PineTime Watch Face in Rust... And Publish on crates.io](https://lupyuen.github.io/pinetime-rust-mynewt/articles/watchface)
* [Getting started with Datalog & Rust for program analysis](https://hexgolems.com/2020/10/getting-started-with-ddlog/)
* [Three open source Sonos projects: efficient embedded development in Rust](https://tech-blog.sonos.com/posts/three-open-source-sonos-projects-in-rust/)

Number: 362  Date: 2020-10-28 

No newsletters this week.
### Official
* [Inside] [Core team membership changes](https://blog.rust-lang.org/inside-rust/2020/10/23/Core-team-membership.html)
### Tooling
* [Rust Analyzer Changelog #48](https://rust-analyzer.github.io/thisweek/2020/10/26/changelog-48.html)
* [Knurling-rs Changelog #3](https://ferrous-systems.com/blog/knurling-changelog-3/)
### Observations/Thoughts
* [Fighting Rust's Expressive Type System](https://thefuntastic.com/blog/fighting-rusts-type-system)
* [XMHell: Handling 38GB of UTF-16 XML with Rust](http://usethe.computer/posts/14-xmhell.html)
* [LudumDare 47 - The Island](https://blog.kuviman.com/2020/10/18/ludumdare47.html)
* [Building a Recipe Manager - Part 3 - Parsing and more Druid](https://bheisler.github.io/post/recipe-manager-part-3-parsing-and-more-druid/)
* [Imitating specialization with OIBITs](https://pwychowaniec.com/en/posts/imitating-specialization-with-oibits/)
* [Flask Creator Armin Ronacher Interview](https://evrone.com/armin-ronacher-interview)
* [clue solver now in Rust with more accurate simulations!](https://gregstoll.wordpress.com/2020/10/22/clue-solver-now-in-rust-with-more-accurate-simulations/)
### Learn Rust
* [Rust for a Gopher Lesson 1](https://levpaul.com/posts/rust-lesson-1/)
* [Rust for a Gopher Lesson 2](https://levpaul.com/posts/rust-lesson-2/)
* [Build a "todo list" backend with AssemblyLift 🚀🔒](https://dev.to/dotxlem/build-a-todo-list-backend-with-assemblylift-1ak3)
* [So you want to write object oriented Rust](https://blog.darrien.dev/posts/so-you-want-to-object/)
* [series] [A Web App in Rust](https://dev.to/krowemoh/series/9410)
* [Contributing to the IntelliJ Rust plugin: Implementing a refactoring](https://kobzol.github.io/rust/intellij/2020/10/19/contributing-4-introduce-constant-refactoring.html)
* [5x Faster Rust Docker Builds with cargo-chef](https://www.lpalmieri.com/posts/fast-rust-docker-builds)
* [Writing a simple AWS Lambda Custom Runtime in Rust](http://jamesmcm.github.io/blog/2020/10/24/lambda-runtime/#en)
* [Is Rust Web Yet? Yes, and it's freaking fast!](http://www.arewewebyet.org/)
* [video] [(Live Coding) Audio adventures in Rust: Local files playback & library interface](https://youtu.be/-tj7ODHX93o)
### Project Updates
* [Introducing Ungrammar](https://rust-analyzer.github.io//blog/2020/10/24/introducing-ungrammar.html)
* A new group of maintainers has taken ownership of the [deps.rs project](https://github.com/deps-rs/deps.rs) and revived the [deps.rs page](https://deps.rs), making the page and generated badges for READMEs usable again.
### Miscellaneous
* [Sandbox Rust Development with Rust Analyzer](https://www.grepular.com/Sandbox_Rust_Development_with_Rust_Analyzer)
* [audio] [Security Headlines: Tokio special with Carl Lerche](https://blog.firosolutions.com/2020/10/tokio_special_with_carl_lerche/)

Number: 363  Date: 2020-11-04 

No Rust Blog posts this week.
### Newsletters
* [RiB Newsletter #17 - Trick? Or Trait?](https://www.reddit.com/r/rust/comments/job17k/rib_newsletter_17_trick_or_trait/)
* [This month in Dimforge #2 (October 2020)](https://www.dimforge.com/blog/2020/11/01/this-month-in-dimforge/)
* [These Weeks in Actix | Sep-Oct '20](https://www.reddit.com/r/rust/comments/jkv5xu/these_weeks_in_actix_sepoct_20/)
### Tooling
* [Rust-Analyzer Changelog #49](https://rust-analyzer.github.io/thisweek/2020/11/02/changelog-49.html)
* [IntelliJ Rust Changelog #134](https://intellij-rust.github.io/2020/11/02/changelog-134.html)
* [IntelliJ Rust: New Functionality for Cargo Features](https://blog.jetbrains.com/clion/2020/10/intellij-rust-new-functionality-for-cargo-features/)
### Observations/Thoughts
* [Semantic FFI Bindings in Rust - Reactivating the Borrow Checker](https://blog.schichler.dev/semantic-ffi-bindings-in-rust-reactivating-the-borrow-checker-ckgxtoxo8057pwrs174dqhcsi)
* [Exception safety in Rust: using transient droppers to prevent memory leaks](http://ngr.yt/blog/2020-11-03-exception-safety-in-rust-using-transient-droppers-to-prevent-memory-leaks.html)
* [Wasmcloud Progress](https://christine.website/blog/wasmcloud-progress-domains-2020-10-31)
* [Fast programming languages: C, C++, Rust, and Assembly](http://tempesta-tech.com/blog/fast-programming-languages-c-c++-rust-assembly)
* [For Complex Applications, Rust is as Productive as Kotlin](https://ferrous-systems.com/blog/rust-as-productive-as-kotlin/)
* [Rust for Data-Intensive Computation](https://github.com/frankmcsherry/blog/blob/master/posts/2020-06-09.md)
* [Using Rust for a simple hardware project](https://blog.tonari.no/rust-simple-hardware-project)
* [The Fatal Flaw of Ownership Semantics](http://www.gingerbill.org/article/2020/06/21/the-ownership-semantics-flaw/)
* [Fixing bootstrap of rustc using cg_clif](https://bjorn3.github.io/2020/11/01/fixing-rustc-bootstrap-with-cg_clif.html)
* [Advanced Cargo [features] Usage](https://blog.turbo.fish/cargo-features/)
### Rust Walkthroughs
* [Rust Design-for-Testability: a survey](https://alastairreid.github.io/rust-testability/)
* [Rust from a Gopher - Lessons 3 & 4](https://levpaul.com/posts/rust-lesson-3-and-4/)
* [Rocket Tutorial 01: Basics](https://dev.to/davidedelpapa/rocket-tutorial-01-basics-4ph9)
* [Building an AWS Lambda extension with Rust](https://dev.to/davidedelpapa/rocket-tutorial-01-basics-4ph9)
* [A Gopher Client in Rust - 02 Core Client](https://dev.to/krowemoh/gopher-client-in-rust-02-core-client-anh)
* [A Gopher Client in Rust - 03 Bookmarks and Full Code](https://dev.to/krowemoh/gopher-client-in-rust-03-extras-4o4d)
* [Rust HTTP Testing with httpmock](https://dev.to/alexliesenfeld/rust-http-testing-with-httpmock-2mi0)
* [The Newtype Pattern in Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)
* [How to: Rust + SDL2 + OpenGL on the web](https://blog.therocode.net/2020/10/a-guide-to-rust-sdl2-emscripten)
* [Minicompiler: Lexing](https://christine.website/blog/minicompiler-lexing-2020-10-29)
* [Continuous Deployment For Rust Applications (Zero To Production In Rust #5)](https://www.lpalmieri.com/posts/2020-11-01-zero-to-production-5-how-to-deploy-a-rust-application/)
* [DE] [The Rust Programming Language (translated in German)](https://rust-lang-de.github.io/rustbook-de/)
* [video] [(Live Coding) Audio adventures in Rust: UI with WASM, Yew, and WebView](https://youtu.be/FaSoPcyOqPE)
* [video] [How to build a multiplayer game - RustFest.Global Pre-Event (Video)](https://www.youtube.com/watch?v=Yb-QR3Vm3sk)
* [video] [Current state of wasm with rust using an example](https://youtu.be/DxzIH1RrIxE)
* [video] [Understanding Rust Lifetimes](https://youtu.be/MSi3E5Z8oRw)
### Project Updates
* [oso, an open-source policy engine for authorization written in Rust](https://github.com/osohq/oso), released [version 0.7.1 of their authorization library for Rust projects!](https://docs.rs/oso/0.7.1/oso/)
* [Apache Arrow 2.0.0 Rust Highlights](https://arrow.apache.org/blog/2020/10/27/rust-2.0.0-release/)
### Miscellaneous
* [One Hundred Rust Binaries](https://www.wezm.net/v2/posts/2020/100-rust-binaries/)
* [Why Dark didn't choose Rust](https://blog.darklang.com/why-dark-didnt-choose-rust/)
* [Rust GameDev Ecosystem Survey](https://www.reddit.com/r/rust/comments/joj5e0/rust_gamedev_ecosystem_survey/)

Number: 364  Date: 2020-11-11 

### Official
* [Inside] [Exploring PGO for the Rust compiler](https://blog.rust-lang.org/inside-rust/2020/11/11/exploring-pgo-for-the-rust-compiler)
### Newsletters
* [This Month in Rust OSDev (October 2020)](https://rust-osdev.com/this-month/2020-10/)
* [This Month in Rust GameDev #15 - October 2020](https://rust-gamedev.github.io/posts/newsletter-015/)
### Tooling
* [Rust-Analyzer Changelog #50](https://rust-analyzer.github.io/thisweek/2020/11/09/changelog-50.html)
* [Develop & Debug Your Rust Application Top Of Kubernetes With OKteto](https://okteto.com/blog/getting-started-with-okteto-and-rust/)
### Observations/Thoughts
* [Rust Ray Tracer, an Update (and SIMD)](https://siliconsprawl.com/2020/11/06/simd-ray-tracer.html)
* [Rust emit=asm Can Be Misleading](https://siliconsprawl.com/2020/11/09/rust-emit-asm.html)
* [A survey into static analyzers configurations: Clippy for Rust, part 1](https://medium.com/monocodus/a-survey-into-static-analyzers-configurations-clippy-for-rust-part-1-5de50fd9326)
* [Why Rust is the Future of Game Development](https://thefuntastic.com/blog/why-rust-is-the-future-game-dev?)
* [Rust as a productive high-level language](https://omarabid.com/rust-high-level-language)
* [40 millisecond bug](https://vorner.github.io/2020/11/06/40-ms-bug.html)
* [Postfix macros in Rust](https://gist.github.com/est31/8d0465997ea920c5ba917cbbf80a822d)
* [A Quick Tour of Trade-offs Embedding Data in Rust](https://nickb.dev/blog/a-quick-tour-of-trade-offs-embedding-data-in-rust)
* [Why Developers Love Rust](https://ibraheem.ca/posts/why-devs-love-rust)
### Rust Walkthroughs
* [Make a Language - Part Nine: Function Calls](https://arzg.github.io/lang/9/)
* [Building a Weather Station UI](https://blog.kdubovikov.ml/articles/rust/ui/weather-station-ui)
* [Getting Graphical Output from our Custom RISC-V Operating System in Rust](https://blog.stephenmarz.com/2020/11/11/risc-v-os-using-rust-graphics/)
* [Build your own: GPG](https://andrewhalle.github.io/build-your-own/gpg)
* [Rpi 4 meets Flutter and Rust](https://dev.to/charliefoxtrot/rpi-4-meets-flutter-and-rust-23ma)
* [AWS Lambda + Rust](https://dev.to/rad_val_/aws-lambda-rust-292g)
* [Orchestration in Rust](https://dev.to/elasticrash/orchestration-in-rust-549b)
* [Rocket Tutorial 02: Minimalist API](https://dev.to/davidedelpapa/rocket-tutorial-02-minimalist-api-2kl6)
* [Get simple IO stats using Rust (throughput, ...)](https://dev.to/martichou/get-simple-io-stats-using-rust-throughput-47m4)
* [Type-Safe Discrete Simulation in Rust](https://dev.to/elshize/type-safe-discrete-simulation-in-rust-3n7d)
* [series] [A Gemini Client in Rust](https://dev.to/krowemoh/series/9524)
* [Postfix macros in Rust](https://gist.github.com/est31/8d0465997ea920c5ba917cbbf80a822d)
* [Processing a Series of Items with Iterators in Rust](https://blog.knoldus.com/processing-a-series-of-items-with-iterators-in-rust/)
* [Compilation of Active Directory Logs Using Rust](https://blog.knoldus.com/compilation-of-active-directory-logs-using-rust/)
* [FR] [The Rust Programming Language (translated in French)](https://jimskapt.github.io/rust-book-fr/)
### Project Updates
* [New doc comment handling in rustdoc](https://blog.guillaume-gomez.fr/articles/2020-11-11+New+doc+comment+handling+in+rustdoc)
### Miscellaneous
* [Rust vs Go](https://bitfieldconsulting.com/golang/rust-vs-go)
* [Learn Assembly by Writing Entirely Too Many Brainf*ck Compilers in Rust](https://github.com/pretzelhammer/rust-blog/blob/master/posts/too-many-brainfuck-compilers.md)

Number: 365  Date: 2020-11-18 

### Official
* [Announcing Rust 1.48.0](https://blog.rust-lang.org/2020/11/19/Rust-1.48.html)
* [Inside] [Source-based code coverage in nightly](https://blog.rust-lang.org/inside-rust/2020/11/12/source-based-code-coverage.html)
### Newsletters
### Tooling
* [IntelliJ Rust Changelog #135](https://intellij-rust.github.io/2020/11/16/changelog-135.html)
* [Rust-Analyzer Changelog #51](https://rust-analyzer.github.io/thisweek/2020/11/16/changelog-51.html)
* [Knurling-rs Changelog #6](https://ferrous-systems.com/blog/knurling-changelog-6/)
### Observations/Thoughts
* [ECS Scheduler Throughs, Part 1](https://ratysz.github.io/article/scheduling-1/)
* [Generating a config file reference for CLI tools in Rust](https://tarquin-the-brave.github.io/blog/posts/generating-config-reference-rust-cli/)
* [Rust in 2021](https://dev.to/tjtelan/rust-in-2021-5p6)
* [Anonymous Sum Types for Rust Error Handling](https://jam1.re/blog/anonymous-sum-types-for-rust-errors)
* [The C Standard Library Is Not Dependency Free](https://prilik.com/blog/post/c-is-not-dependency-free/)
* [Scoped Trait Implementation](https://jack.wrenn.fyi/blog/private-trait-impls/)
### Rust Walkthroughs
* [SQLite File Parser Pt. 2: The Header... continues](https://freemasen.com//blog/sqlite-parser-pt-2/index.html)
* [Rust from a Gopher - Lessons 7, 8 & 9](https://levpaul.com/posts/rust-lesson-7-8-9/)
* [Writing an embedded display driver in Rust](https://nitschinger.at/Writing-an-embedded-display-driver-in-Rust/)
* [Rocket Tutorial 03: Proper routing](https://dev.to/davidedelpapa/rocket-tutorial-03-proper-routing-4ch3)
* [Intro to Yew, a Rust Frontend Framework](https://dev.to/fllstck/intro-to-yew-a-rust-frontend-framework-20hb)
* [An Ownership Puzzle with Rust, Async, and Hyper](https://www.fpcomplete.com/blog/ownership-puzzle-rust-async-hyper/)
* [Make A Language - Part Ten: Starting Again](https://arzg.github.io/lang/10/)
* [Make A Language - Part Eleven: Refinements](https://arzg.github.io/lang/11/)
* [OS in Rust: Custom target to build kernel for a bare metal: Part-3](https://blog.knoldus.com/os-in-rust-custom-target-to-build-kernel-for-a-bare-metal-part-3/)
* [Creating a Tetris Clone in Rust, with Bevy (Part 1)](https://corbamico.github.io/2020/11/12/tetris-1/)
* [PL] [CrabbyBird #3 Generowanie świata gry – cześć I](https://postacnormalna.pl/crabbybird-3-generowanie-swiata-gry-czesc-i/)
* [video] [Crust of Rust: Sorting Algorithms](https://youtu.be/h4RkCyJyXmM)
* [video] [(Live Coding) Audio adventures in Rust: UI with Actix, WebView, and React](https://youtu.be/vmvq9jKBlGc)
### Project Updates
* [The Big Picture of gfx/wgpu ecosystem](https://gfx-rs.github.io/2020/11/16/big-picture.html)
* [xd(1): hex-dumping tool with a ♥♪ code page 437 twist ♫♥](https://www.azabani.com/2020/11/15/xd.html)
* [Fwumious Wabbit: really fast logistic regression (+more) in Rust](https://andraztori.medium.com/speed-is-a-feature-introducing-fwumious-wabbit-1cc9573ea7be)
* [Rust for Modding Smash Ultimate](https://jam1.re/blog/rust-for-game-modding)
* [reacty_yew: Generating Yew components from React components via Typescript type definitions](https://www.hobofan.com/blog/2020-11-10-reacty_yew/)
* [Servo's New Home](https://blog.servo.org/2020/11/17/servo-home/)
### Miscellaneous
* [Dog Fight — Python VS Golang VS Rust for JSON Processing](https://medium.com/swlh/dog-fight-python-vs-golang-vs-rust-for-json-processing-33c1ffe15ab9)
* [Build an SMS Alert System over the weekend with Rust and Zero-Cost](https://towardsdatascience.com/build-an-sms-alert-system-for-canada-covid-19-cases-over-the-weekend-with-rust-and-zero-cost-235bb59ec5d)
* [Build a Scalable Trading Bot With Rust Over the Weekend](https://medium.com/swlh/build-a-scalable-trading-bot-with-rust-over-the-weekend-9fd781940360)
* [Oh No! My Data Science Is Getting Rust-y](https://www.crowdstrike.com/blog/data-science-test-drive-of-rust-programming-language/)
* [The Usability of Ownership](https://arxiv.org/abs/2011.06171)

Number: 366  Date: 2020-11-25 

### Official
* [Inside] [What the Error Handling Project Group is Working On](https://blog.rust-lang.org/inside-rust/2020/11/23/What-the-error-handling-project-group-is-working-on.html)
### Newsletters
### Tooling
* [Rust Analyzer Changelog #52](https://rust-analyzer.github.io/thisweek/2020/11/23/changelog-52.html)
* [Knurling-rs Changelog #7](https://ferrous-systems.com/blog/knurling-changelog-7/)
### Observations/Thoughts
* [FlatBuffer as serialization agnostic IDL](https://adsharma.github.io/flattools-11222020.html)
* [WTF is Rust? The Illustrated Notes](https://dev.to/egghead/wtf-is-rust-the-illustrated-notes-564p)
* [First Lines of Rust](https://dev.to/arschles/first-lines-of-rust-ofe)
* [Optimizing Benchpress](https://blog.nodebb.org/optimizing-benchpress/)
* [pwintln uwu and other fun with elves and dynamic linkers](https://lfcode.ca/blog/pwintln-uwu)
### Rust Walkthroughs
* [Hands-on Rust: Effective Learning through 2D Game Development and Play](https://pragprog.com/titles/hwrust/hands-on-rust/)
* [CBOR IoT Data Serialization for Embedded C and Rust](https://www.jaredwolff.com/cbor-for-embedded-c-and-rust/)
* [Basic Interactions with Yew](https://dev.to/fllstck/basic-interactions-with-yew-3pa3)
* [Testing your crate C-API](https://dev.to/luzero/testing-your-crate-c-api-19nc)
* [Rocket Tutorial 03 part II: Proper Testing](https://dev.to/davidedelpapa/rocket-tutorial-03-part-ii-proper-testing-6h)
* [Select Syscall in Rust](https://dev.to/pjam/select-syscall-in-rust-mm)
* [FBSim: football-playing AI agents in Rust](https://iantayler.com/2020/11/22/fbsim-football-playing-ai-agents-in-rust/)
* [Building a Recipe Manager - Part 5 - Data Integrity](https://bheisler.github.io/post/recipe-manager-part-5-data-integrity/)
* [Bootstrapping support for the STM32WLE with the Embedded Rust ecosystem](https://jitter.company/blog/2020/11/23/bootstrapping-support-for-the-stm32wle-with-the-embedded-rust-ecosystem/)
* [Recipe for Calling Swift Closures from Asynchronous Rust Code](https://www.nickwilcox.com/blog/recipe_swift_rust_callback/)
* [video] [A Cool Generic Concurrency Primitive in Rust](https://youtu.be/eLNAMEoKAAc)
* [video] [Creative coding in Rust: re-creating a retro screensaver](https://youtu.be/d9lsT4kJo44)
* [video] [(Live Coding) Audio adventures in Rust: Packaging Actix + React app as macOS bundle](https://youtu.be/2u362vR167c)
* [video] [Prototype (Rust tutorial) - Design Patterns](https://www.youtube.com/watch?v=lL0PmeYWqiU&feature=youtu.be)
### Project Updates
* [cargo-mobile: Rust on mobile made easy!](https://dev.brainiumstudios.com/2020/11/24/cargo-mobile.html)
* [Welcoming the RustFest Project](https://blog.rustfest.eu/rustfest-project-announcement)
* [Levenshtein Heuristic in Poi](https://advancedresearch.github.io/blog/2020-11-21-levenshtein-heuristic-in-poi)
### Miscellaneous
* [Strengthening memory safety in Rust: exploring CHERI capabilities for a safe language](https://nw0.github.io/cheri-rust.pdf)
* [Why AWS loves Rust, and how we'd like to help](https://aws.amazon.com/blogs/opensource/why-aws-loves-rust-and-how-wed-like-to-help/#)
* [Why Work in Blockchain? - Journey from C++ to Rust Developer](https://medium.com/centrality/why-work-in-blockchain-journey-from-c-to-rust-developer-eddbc9ccdc3d)
* [Flash Animations Live Forever at the Internet Archive [via ruffle.rs, a Flash emulator written in Rust compiled to WASM]](https://www.reddit.com/r/rust/comments/jxfhnp/flash_animations_live_forever_at_the_internet/)
* [video] [How to create an awesome Rust GitHub project](https://www.youtube.com/watch?v=meAz2RQMHvM)

Number: 367  Date: 2020-12-2 

No project updates this week.
### Official
* [Announcing Rustup 1.23.0](https://blog.rust-lang.org/2020/11/27/Rustup-1.23.0.html)
### Newsletters
* [This Month in Rust Dimforge #3](https://www.dimforge.com/blog/2020/12/01/this-month-in-dimforge/)
### Tooling
* [IntelliJ Rust Changelog #136](https://intellij-rust.github.io/2020/11/30/changelog-136.html)
* [Rust Analyzer Changelog #53](https://rust-analyzer.github.io/thisweek/2020/11/30/changelog-53.html)
* [Knurling-rs Changelog #8](https://ferrous-systems.com/blog/knurling-changelog-8/)
### Observations/Thoughts
* [Rust Continuous Delivery](https://kflansburg.com/posts/rust-continuous-delivery/)
* [Why doesn't Rust's BTreeMap have a with_capacity() method?](https://www.nicolas-hahn.com/2020/11/30/btreemap-with-capacity/)
* [Why using WebAssembly and Rust together improves Node.js performance](https://developer.ibm.com/technologies/web-development/articles/why-webassembly-and-rust-together-improve-nodejs-performance/)
* [lib-ruby-parser](https://ilyabylich.svbtle.com/lib-ruby-parser)
* [Understanding Partial Moves in Rust](https://whileydave.com/2020/11/30/understanding-partial-moves-in-rust/)
* [Error Handling is Hard](https://www.fpcomplete.com/blog/error-handling-is-hard/)
* [Scalable Benchmarking with Rust Streams](https://pkolaczk.github.io/benchmarking-cassandra-with-rust-streams/)
* [I rewrote 10k lines of JS into Rust over the last month. Here's a write up about it](https://www.reddit.com/r/rust/comments/k3jy5g/i_rewrote_10k_lines_of_js_into_rust_over_the_last/)
### Rust Walkthroughs
* [References in Rust](https://hashrust.com/blog/references-in-rust/)
* [OS in Rust: Building kernel for custom target: Part-4](https://blog.knoldus.com/os-in-rust-building-kernel-for-custom-target-part-4/)
* [Writing Rust the Elixir way](https://dev.to/bkolobara/writing-rust-the-elixir-way-2lm8)
* [Risp (in (Rust) (Lisp))](https://stopa.io/post/222)
* [Props and Nested Components with Yew](https://dev.to/fllstck/props-and-nested-components-with-yew-2l0d)
* [Using Selenium with Rust](https://dev.to/stevepryde/using-selenium-with-rust-aca)
* [Rocket Tutorial 04: Data Persistency and Rocket (with MongoDB)](https://dev.to/davidedelpapa/rocket-tutorial-04-data-persistency-and-rocket-with-mongodb-e5j)
* [The Little Book of Rust Macros](https://veykril.github.io/tlborm/)
* [series] [Futures Explained in 200 Lines of Rust](https://cfsamson.github.io/books-futures-explained/introduction.html)
* [video] [Demo: 🦀️ Building a runtime reflection system for Rust](https://www.osohq.com/post/demo-building-runtime-reflection-system-for-rust)
* [video] [Sapling livestream 5 - Deleting Code](https://youtu.be/oc8DWXsodzE)
### Miscellaneous
* [Why scientists are turning to Rust](https://www.nature.com/articles/d41586-020-03382-2)
* [Pijul - The Mathematically Sound Version Control System Written In Rust](https://initialcommit.com/blog/pijul-version-control-system)
* [Amazon: We're hiring software engineers who know programming language Rust](https://www.zdnet.com/article/amazon-were-hiring-software-engineers-who-know-programming-language-rust/)

Number: 368  Date: 2020-12-9 

### Official
* [The Foundation Conversation](https://blog.rust-lang.org/2020/12/07/the-foundation-conversation.html)
### Newsletters
* [This Month in Rust GameDev #16 - November 2020](https://rust-gamedev.github.io/posts/newsletter-016/)
* [RiB Newsletter #18 - On to the Ribbles](https://www.reddit.com/r/rust/comments/k6cka7/rib_newsletter_18_on_to_the_ribbles/)
### Tooling
* [Rust Analyzer Changelog #54](https://rust-analyzer.github.io/thisweek/2020/12/07/changelog-54.html)
* [Knurling-rs Changelog #9](https://ferrous-systems.com/blog/knurling-changelog-9/)
* [IntelliJ Rust: Updates for 2020.3](https://blog.jetbrains.com/clion/2020/12/intellij-rust-updates-for-2020-3/)
### Observations/Thoughts
* [Monads and GATs in Nightly Rust](https://www.fpcomplete.com/blog/monads-gats-nightly-rust/)
* [Vanishing zeroes for geometric algebra in Rust](https://fanf.dreamwidth.org/134024.html)
* [On Generics and Associated Types](https://blog.thomasheartman.com/posts/on-generics-and-associated-types)
* [Adaptive Request Concurrency. Resilient observability at scale.](https://vector.dev/blog/adaptive-request-concurrency/)
* [Rust compression libraries](https://blog.logrocket.com/rust-compression-libraries/)
* [Rust makes cross compilation child's play](https://www.marcoieni.com/2020/12/rust-makes-cross-compilation-childs-play/)
* [Using the builder pattern to define test scenarios](https://jmmv.dev/2020/12/builder-pattern-for-tests.html)
* [Measuring Memory Usage in Rust](https://rust-analyzer.github.io/blog/2020/12/04/measuring-memory-usage-in-rust.html)
* [Saving time by switching users: Async support in Goose](https://www.tag1consulting.com/blog/saving-time-switching-users-async-support-goose)
* [Why Rust is meant to replace C](https://evrone.com/rust-vs-c)
### Rust Walkthroughs
* [Real-time video processing with Rust, FFmpeg and OpenCV](https://subvisual.com/blog/posts/real-time-video-processing-with-rust-ffmpeg-opencv/)
* [Merge k sorted arrays in Rust](https://dev.to/creativcoder/merge-k-sorted-arrays-in-rust-1b2f)
* [Make A Language - Part Thirteen: Whitespace & Events](https://arzg.github.io/lang/13/)
* [Unit-testing a console app (a text editor)](https://jmmv.dev/2020/12/unit-testing-a-console-app.html)
* [Rust and Async (on embedded devices)](https://blog.drogue.io/rust-and-async/)
* [Avoiding Duplicating Strings in Rust](https://www.fpcomplete.com/blog/avoiding-duplicating-strings-rust/)
* [OS in Rust: Custom target to build kernel for bare metal: Part-3](https://blog.knoldus.com/os-in-rust-custom-target-to-build-kernel-for-a-bare-metal-part-3/)
* [OS in Rust: Building kernel for custom target: Part-4](https://blog.knoldus.com/os-in-rust-building-kernel-for-custom-target-part-4/)
* [video] [Introduction to Rust Part 2](https://youtu.be/lLWchWTUFOQ)
### Project Updates
* [rust-gpu v0.2](https://github.com/EmbarkStudios/rust-gpu/releases/tag/v0.2)
* [Interior Mutability in Rust: Understanding The Cell Type](https://ibraheem.ca/posts/rust-interior-mutability-understanding-cell)
### Miscellaneous
* [Safe Interoperability between Rust and C++ with CXX](https://www.infoq.com/news/2020/12/cpp-rust-interop-cxx/)
* [Expanding Fuchsia's open source model](https://opensource.googleblog.com/2020/12/expanding-fuchsias-open-source-model.html)
* [Miri can now detect data races](https://www.reddit.com/r/rust/comments/k75tez/miri_can_now_detect_data_races/)

Number: 369  Date: 2020-12-16 

### Official
* [Launching the Lock Poisoning Survey](https://blog.rust-lang.org/2020/12/11/lock-poisoning-survey.html)
* [Next steps for the Foundation Conversation](https://blog.rust-lang.org/2020/12/14/Next-steps-for-the-foundation-conversation.html)
* [Rust Survey 2020 Results](https://blog.rust-lang.org/2020/12/16/rust-survey-2020.html)
* [Inside] [Changes to Rust Compiler Team](https://blog.rust-lang.org/inside-rust/2020/12/14/changes-to-compiler-team.html)
### Newsletters
* [This Month in Rust OSDev (November 2020)](https://rust-osdev.com/this-month/2020-11/)
### Tooling
* [IntelliJ Rust Changelog #137](https://intellij-rust.github.io/2020/12/14/changelog-137.html)
* [Rust Analyzer Changelog #55](https://rust-analyzer.github.io/thisweek/2020/12/14/changelog-55.html)
* [Knurling-rs Changelog #10](https://ferrous-systems.com/blog/knurling-changelog-10/)
* [These Months in explaine.rs](https://jrvidal.github.io/explaine.rs/blog/these-months-in-explainers.html)
* [Cargo2nix 0.9.0 release notes](https://github.com/cargo2nix/cargo2nix/releases/tag/v0.9.0)
### Observations/Thoughts
* [FFI-Safe Polymorphism: Thin Trait Objects](https://adventures.michaelfbryan.com/posts/ffi-safe-polymorphism-in-rust/)
* [Adding BPF target support to the Rust compiler](https://confused.ai/posts/rust-bpf-target)
* [Why Rust Has a Bright Future in the Cloud](https://www.qovery.com/blog/why-rust-has-a-bright-future-in-the-cloud)
* [Closures: Magic Functions](https://rustyyato.github.io/rust/syntactic/sugar/2019/01/17/Closures-Magic-Functions.html)
* [Notes on cross-compiling Rust](https://john-millikin.com/notes-on-cross-compiling-rust)
* [Polymorphism in Rust: Enums vs Traits](https://www.mattkennedy.io/blog/rust_polymorphism/)
* [Beyond R and Python: Rust for Science](https://scie.nz/rust/)
* [Pointers Are Complicated II, or: We need better language specs](https://www.ralfj.de/blog/2020/12/14/provenance.html)
* [Serde tricks: The lesson learnt from refactoring rspotify](https://0x709394.me/Serde-tricks)
* [Notes On Lock Poisoning](https://matklad.github.io/2020/12/12/notes-on-lock-poisoning.html)
* [I tried to make the fastest sorting algorithm I could think of... in Rust](https://danielvz.cl/blog/fast-rust.html)
* [Still Rusting - One Year Later](https://deislabs.io/posts/still-rusting-one-year-later/)
* [6 Principles for Building Robust Flexible Shared Data Apps with Rust & MongoDB](https://developer.mongodb.com/article/six-principles-building-robust-flexible-shared-data-applications)
* [video] [The Unsafe Chronicles: Exhibit A: Aliasing Boxes](https://youtu.be/EY7Wi9fV5bk)
### Rust Walkthroughs
* [Make A Language - Part Fourteen: Comments](https://arzg.github.io/lang/14/)
* [Make A Language - Part Fifteen: Markers](https://arzg.github.io/lang/15/)
* [Rust, Python and Fish](https://benjamin.computer/posts/2020-12-12-rust-python.html)
* [Chess game in Rust using Bevy](https://caballerocoll.com/blog/bevy-chess-tutorial/)
* [Rust on the BBC micro:bit](https://blog.drogue.io/rust-and-microbit/)
* [Developing smart contracts with ink!](https://dev.to/yangwao/developing-smart-contracts-with-ink-4g72)
* [Learn SixtyFPS: Memory Game Tutorial (Rust)](https://sixtyfps.io/blog/memory-game-tutorial.html)
* [Aiming for correctness with types](https://fasterthanli.me/articles/aiming-for-correctness-with-types)
* [Zero to Production in Rust #6: Using Types To Guarantee Domain Invariants](https://www.lpalmieri.com/posts/2020-12-11-zero-to-production-6-domain-modelling/)
* [FFI-Safe Polymorphism: Thin Trait Objects](https://adventures.michaelfbryan.com/posts/ffi-safe-polymorphism-in-rust/)
* [Distributing Rust Analyzer with Nix and Cargo2nix](https://github.com/cargo2nix/cargo2nix/tree/master/examples/4-independent-packaging)
* [PL] [CrabbyBird #4 Generowanie świata gry – cześć II](https://postacnormalna.pl/crabbybird-4-generowanie-swiata-gry-czesc-ii/)
* [video] [How oso built a runtime reflection library for Rust](https://youtu.be/J7Aosp1Uauo)
* [video] [Implementing Rust's Vec From Scratch](https://youtu.be/3OL95gZgPWA)
* [RU] [video] [Rust: Not as hard as you think / Russian Rust Online Meetup](https://www.youtube.com/watch?v=yCrc5BwZrtw)
### Project Updates
* [These Months in explaine.rs](https://jrvidal.github.io/explaine.rs/blog/these-months-in-explainers.html)
* [Sequoia PGP](https://www.sequoia-pgp.org/) released [version 1.0](https://sequoia-pgp.org/blog/2020/12/16/202012-1.0/)
* [Connect devices to blockchains with Léger](http://www.cyrilfougeray.com/2020/12/14/leger-rust-wallet-1.html)
### Miscellaneous
* [Signal Group Calls are powered by Rust](https://www.reddit.com/r/rust/comments/kdo06l/signal_group_calls_are_powered_by_rust/)
* [Rust's Option in One Figure](https://www.reddit.com/r/rust/comments/kdfb9k/rusts_option_in_one_figure/)
* [Authors of "Programming Rust 2nd Edition" have a sense of humor](https://www.reddit.com/r/rust/comments/kcou9c/authors_of_programming_rust_2nd_edition_have_a/)
* [Rotating the compiler team leads](https://smallcultfollowing.com/babysteps/blog/2020/12/11/rotating-the-compiler-team-leads/)
* [Debug Rust on PineCone BL602 with VSCode and GDB](https://lupyuen.github.io/articles/debug)
* [RU] [audio] [SitCast#32 - Эх, Rust, да ещё Rust…](https://www.youtube.com/watch?v=w99C9heBWHE&feature=youtu.be)

Number: 370  Date: 2020-12-23 

No official blog posts or newsletters this week.
### Project/Tooling Updates
* [Rust Analyzer Changelog #56](https://rust-analyzer.github.io/thisweek/2020/12/21/changelog-56.html)
* [Knurling-rs Changelog #11](https://ferrous-systems.com/blog/knurling-changelog-11/)
* [Bevy 0.4](https://bevyengine.org/news/bevy-0-4/)
* [Announcing Tokio 1.0](https://tokio.rs/blog/2020-12-tokio-1-0)
* [hyper 0.14](https://seanmonstar.com/post/638320652536922112/hyper-v014)
* [RustFFT 5.0.0.experimental-1: Now faster than FFTW!](https://users.rust-lang.org/t/rustfft-5-0-0-experimental-1-now-faster-than-fftw/53049)
* [Allsorts Font Shaping Engine Year in Review](https://yeslogic.com/blog/allsorts-rust-font-shaping-engine-2020-review/)
### Observations/Thoughts
* [Looking back on 2020](http://smallcultfollowing.com/babysteps/blog/2020/12/18/looking-back-on-2020/)
* [I rewrote a Clojure tool in Rust](https://timofreiberg.github.io/clojure-vs-rust/)
* [🦀 Rust Reviewed: Is the hype justified? 🦀](https://dev.to/somedood/rust-reviewed-is-the-hype-justified-1pa1)
* [Three things I wish I'd known learning Rust](https://www.darkcoding.net/software/three-things-i-wish-id-known-learning-rust/)
* [Rust in a KDE Project](https://jbbgameich.github.io/misc/2020/12/21/rust-in-a-kde-project.html)
* [First 3 Months of Rust](https://www.reddit.com/r/rust/comments/khrt69/first_3_months_of_rust/)
* [How rust changed and saved my life](https://www.reddit.com/r/rust/comments/khlln4/how_rust_changed_and_saved_my_life/)
* [Problems with building backend app in Rust in 2020](https://blog.0xfa.be/building-a-backend-app-in-rust/)
* [Reaching the (current) limits of Rust's type system with asynchronous programming](https://gendignoux.com/blog/2020/12/17/rust-async-type-system-limits.html)
* [audio] [Rust GameDev Podcast - Interview with Fedor Logachev](https://rustgamedev.com/episodes/interview-with-fedor-logachev)
### Rust Walkthroughs
* [Build your own async primitive](https://tweedegolf.nl/blog/50/build-your-own-async-primitive)
* [Make A Language - Part Sixteen: Refactoring](https://arzg.github.io/lang/16/)
* [Make A Language - Part Seventeen: Crates](https://arzg.github.io/lang/17/)
* [Make A Language - Part Eighteen: Errors](https://arzg.github.io/lang/18/)
* [A Simple Neural Network (<200LoC, Rust)](https://explog.in/notes/funnn.html)
* [Rocket Tutorial 05: Enforcing uniqueness of emails](https://dev.to/davidedelpapa/rocket-tutorial-05-enforcing-uniqueness-of-emails-136j)
* [How to write a Terminal Multiplexer with Rust, Async, and Actors - Part 2](https://implaustin.hashnode.dev/how-to-write-a-terminal-multiplexer-with-rust-async-and-actors-part-2)
* [Learning Rust: static trait bounds](https://codeandbitters.com/static-trait-bound/)
* [Async: What is blocking?](https://ryhl.io/blog/async-what-is-blocking/)
* [Schedule the program in Rust](https://blog.knoldus.com/schedule-the-program-in-rust/)
* [video] [Generic Associated Types - Learn Rust](https://www.youtube.com/watch?v=JwG-Wa7dOBU&feature=youtu.be)
* [video] [series] [Rust Tutorial](https://youtube.com/playlist?list=PLLqEtX6ql2EyPAZ1M2_C0GgVd4A-_L4_5)
### Miscellaneous
* [A Potential Rust Learning Project Group](https://internals.rust-lang.org/t/a-potential-rust-learning-project-group/13620)
* [Watch all of RustFest Global](https://blog.rustfest.eu/watch-all-of-rustfest)
* [When to use Rust?](https://www.reddit.com/r/rust/comments/kgw8bz/when_to_use_rust/)
* [Hyper support is merged to curl master](https://www.reddit.com/r/rust/comments/kgcye2/hyper_support_is_merged_to_curl_master/)
* [Just wanted to say thanks to the Rust community!](https://www.reddit.com/r/rust/comments/kfiaqn/just_wanted_to_say_thanks_to_the_rust_community/)

Number: 371  Date: 2020-12-30 

No newsletters this week.
### Official
* [Inside] [Please welcome cjgillot and Nadrieril to compiler-contributors](https://blog.rust-lang.org/inside-rust/2020/12/28/cjgillot-and-nadrieril-for-compiler-contributors.html)
* [Inside] [1.49.0 pre-release testing](https://blog.rust-lang.org/inside-rust/2020/12/29/1.49.0-prerelease.html)
### Project/Tooling Updates
* [IntelliJ Rust Changelog #138](https://intellij-rust.github.io/2020/12/28/changelog-138.html)
* [Rust Analyzer Changelog #57](https://rust-analyzer.github.io/thisweek/2020/12/28/changelog-57.html)
* [Redox OS 0.6.0](https://www.redox-os.org/news/release-0.6.0/)
### Observations/Thoughts
* [Call Site Dependency Injection](https://matklad.github.io/2020/12/28/csdi.html)
* [A look at tokio 1.0 API Changes](https://leshow.github.io/post/udp_tokio_1_0/)
* [Memory-Safety Challenge Considered Solved? An In-Depth Study with All Rust CVEs](https://arxiv.org/abs/2003.03296)
* [45,000+ lines of Rust code later: An update on the Record & Debug Tool (rd)](https://github.com/sidkshatriya/me/blob/master/003-Rd-makes-significant-advances.md)
* [Cloning A Reference and Method Call Syntax in Rust](https://www.fpcomplete.com/blog/cloning-reference-method-calls/)
* [Executable PNGs](https://djharper.dev/post/2020/12/26/executable-pngs/)
* [Why mongodump is fast](https://windsoilder.github.io/why_mongodump_is_fast.html)
* [A look at tokio 1.0 API Changes](https://leshow.github.io/post/udp_tokio_1_0/)
### Rust Walkthroughs
* [Concurrency in modern programming languages: Rust](https://dev.to/deepu105/concurrency-in-modern-programming-languages-rust-19co)
* [Building distributed GraphQL backend using Rust and Apollo Federation](https://dev.to/rkudryashov/building-distributed-graphql-backend-using-rust-and-apollo-federation-50bm)
* [Enhance code quality using `matches` macro! in Rust](https://blog.knoldus.com/enhance-code-quality-using-matches-macro-in-rust/)
* [ClickOnce for Rust Apps](https://taggartsoftware.medium.com/clickonce-for-rust-apps-f96873feb8f1)
* [Closures in Rust](https://zhauniarovich.com/post/2020/2020-12-closures-in-rust/)
* [Don't let failures spread over your suite with process-based tests isolation](https://blog.cyplo.dev/posts/2020/12/fail-and-fork/)
* [Triangle From Scratch](https://rust-tutorials.github.io/triangle-from-scratch/opening_a_window/win32.html)
* [video] [series] [(Live Coding) Advent of Code 2020 in Rust](https://youtube.com/playlist?list=PLoSY6azqHO7BpQo8jWKi4cFIobJo-TCzU)
### Miscellaneous
* [Redox OS 0.6 Released With Many Fixes, Rewritten Kernel Memory Manager](https://www.phoronix.com/scan.php?page=news_item&px=Redox-OS-0.6-Released)
* [The more things change...](https://smallcultfollowing.com/babysteps/blog/2020/12/30/the-more-things-change/)
* [Min const generics stabilization has been merged into master! It will reach stable on March 25, 2021 as part of Rust 1.51](https://www.reddit.com/r/rust/comments/kl1e24/min_const_generics_stabilization_has_been_merged/)

Number: 372  Date: 2021-01-06 

### Official
* [Announcing Rust 1.49.0](https://blog.rust-lang.org/2020/12/31/Rust-1.49.0.html)
* [mdBook security advisory](https://blog.rust-lang.org/2021/01/04/mdbook-security-advisory.html)
### Newsletters
* [RiB Newsletter #19 - Rust and smart contracts](https://www.reddit.com/r/rust/comments/ks5ivd/rib_newsletter_19_rust_and_smart_contracts/)
### Project/Tooling Updates
* [Rust Analyzer Changelog #58](https://rust-analyzer.github.io/thisweek/2021/01/04/changelog-58.html)
* [Rust Search Extension Changelog v1.1](https://rust.extension.sh/changelog/#v1-1-2021-01-07)
* [Rust Design Patterns now also as a book](https://www.reddit.com/r/rust/comments/kowtqn/rust_design_patterns_now_also_as_a_book/)
* [Pijul - How to survive?](https://pijul.org/posts/2021-01-05-how-to-survive/)
* [RustFFT 5.0 has been released!](https://users.rust-lang.org/t/rustfft-5-0-has-been-released/53709)
* [napi 1.0 released](https://napi.rs)
* [Insta got a new website with docs](https://insta.rs/) and a [Visual Studio Code Extension](https://marketplace.visualstudio.com/items?itemName=mitsuhiko.insta)
* [Isahc 1.0 and Retrospective](https://stephencoakley.com/2020/12/29/isahc-1.0-and-retrospective)
* [slotmap 1.0 has been released! Copy restriction removed, no_std support, and more](https://www.reddit.com/r/rust/comments/kq6lt2/slotmap_10_has_been_released_copy_restriction/)
* [libbpf-rs: eBPF for the Rust ecosystem](https://dxuuu.xyz/libbpf-rs.html)
### Observations/Thoughts
* [Reflecting on developing a database (2020 edition)](https://alex-dukhno.github.io/2020-12-31-Reflecting-on-developing-a-database-(2020-edition)/)
* [bore(1) + nonymous: lessons learned writing a DNS query tool and `#![no_std]` DNS library](https://www.azabani.com/2021/01/03/nonymous-bore.html)
* [Exploring RustFFT's SIMD Architecture](https://users.rust-lang.org/t/exploring-rustffts-simd-architecture/53780)
* [Understanding Yew Part 1](https://dev.to/rusty_sys_dev/understanding-yew-part-1-3cfn)
* [Transposing options/results with iterators](https://dev.to/elshize/transposing-options-results-with-iterators-aj3)
* [Dark side of POSIX APIs](https://vorner.github.io/2021/01/03/dark-side-of-posix-apis.html)
* [Redesigning coca's Storage Abstraction](https://gist.github.com/teryror/7b9a23fd0cd8dcfbcb6ebd34ee2639f8)
* [Generic associated types encode higher-order functions on types](https://willcrichton.net/notes/gats-are-hofs/)
* [Rust's SemVer Snares: Sizedness and Size](https://jack.wrenn.fyi/blog/semver-snares-size/)
* [Why using WebAssembly and Rust together improves Node.js performance](https://developer.ibm.com/articles/why-webassembly-and-rust-together-improve-nodejs-performance/)
### Rust Walkthroughs
* [Building a runtime reflection system for Rust 🦀️ (Part 3)](https://www.osohq.com/post/runtime-reflection-pt-3)
* [Writing a Kubernetes CRD Controller in Rust](http://technosophos.com/2019/08/07/writing-a-kubernetes-controller-in-rust.html)
* [Adding FFI Support in x7](https://dpbriggs.ca/blog/Adding-FFI-Support-In-x7)
* [Recursive Iterators in Rust](https://fasterthanli.me/articles/recursive-iterators-rust)
* [Writing a Prometheus MPD Exporter](https://beyermatthias.de/blog/2021/01/03/writing-a-prometheus-mpd-exporter/)
* [Rust Programming Language Tutorial - How to Build a To-Do List App](https://www.freecodecamp.org/news/how-to-build-a-to-do-app-with-rust/)
* [Diving into Rust with a CLI](https://dev.to/kbknapp/diving-into-rust-with-a-cli-4gap)
* [Creating a GUI for a Rust application](https://dev.to/henrybarreto/creating-a-gui-for-a-rust-application-2h1g)
* [Zero to Production #6.5: An Introduction To Property-Based Testing In Rust](https://www.lpalmieri.com/posts/an-introduction-to-property-based-testing-in-rust/)
* [Holiday Hacking - Tracking my heart rate while playing Call of Duty](https://jcdav.is/2021/01/04/Holiday-Hacking-COD-HR/)
* [Introducing Rustybot (part 1 of n)](https://objectdisoriented.evokewonder.com/posts/introducing-rustybot-part-1/)
* [Introducing Rustybot (part 2 of n)](https://objectdisoriented.evokewonder.com/posts/introducing-rustybot-part-2/)
* [Extracting Files From an Archive Format I Understand Way Too Much](https://jam1.re/blog/extracting-files-from-an-archive-format-i-understand-way-too-much)
* [series] [eBPF Networking in Rust](https://dev.to/kbknapp/series/10570)
* [video] [FLTK Rust: use FLUID (RAD tool) with Rust](https://youtu.be/k_P0wG3-dNk)
### Miscellaneous
* [Rust 1.49.0 Released With 64-bit ARM Linux Support Rated Tier-1](https://www.phoronix.com/scan.php?page=news_item&px=Rust-1.49-Released)
* [Rust will drop official support for Windows XP](https://www.reddit.com/r/rust/comments/knpvv9/rust_will_drop_official_support_for_windows_xp/)
* [Rust is the second most used language for Advent of Code, after Python](https://www.reddit.com/r/rust/comments/knyoej/rust_is_the_second_most_used_language_for_advent/)
* [Rust grew 94% on O'Reilly online learning this year](https://www.reddit.com/r/rust/comments/kp1piy/rust_grew_94_on_oreilly_online_learning_this_year/)
* [Rust is now overall faster than C in benchmarks](https://www.reddit.com/r/rust/comments/kpqmrh/rust_is_now_overall_faster_than_c_in_benchmarks/)

Number: 373  Date: 2021-01-13 

### Official
### Newsletters
* [This Month in Rust GameDev #17 - December 2020](https://rust-gamedev.github.io/posts/newsletter-017/)
* [This Month in Rust OSDev (December 2020)](https://rust-osdev.com/this-month/2020-12/)
### Project/Tooling Updates
* [rust-analyzer Changelog #59](https://rust-analyzer.github.io/thisweek/2021/01/11/changelog-59.html)
* [Knurling-rs Changelog #12](https://ferrous-systems.com/blog/knurling-changelog-12/)
* [GCC Rust – How it can be achieved](https://www.embecosm.com/2021/01/12/gcc-rust-how-it-can-be-achieved/)
* [Open Source Security, Inc. Announces Funding of GCC Front-End for Rust](https://opensrcsec.com/open_source_security_announces_rust_gcc_funding)
* [Progress report on rustc_codegen_cranelift (Dec 2020)](https://bjorn3.github.io/2021/01/07/progress-report-dec-2020.html)
### Observations/Thoughts
* [XML parsing in Rust](https://simplabs.com/blog/2020/12/31/xml-and-rust/)
* [parsing baseball files in Rust instead of Python for an 8x speedup!](https://gregstoll.wordpress.com/2021/01/10/parsing-baseball-files-in-rust-instead-of-python-for-an-8x-speedup/)
* [Philosophies of Rust and Haskell](https://www.fpcomplete.com/blog/philosophies-rust-haskell/)
* [Maybe you don't need Rust and WASM to speed up your JS](https://mrale.ph/blog/2018/02/03/maybe-you-dont-need-rust-to-speed-up-your-js.html)
* [Simplifying Endian-Specific file parsers in Rust with Omnom and type inference](https://www.parsed.uk/articles/Simplifying_EndianSpecific_file_parsers_in_Rust_with_Omnom_and_type_inference)
* [Rust's SemVer Snares: repr(transparent) Super-Cut](https://jack.wrenn.fyi/blog/semver-snares-transparent/)
* [Exploiting Mixed Binaries](https://www.cs.ucy.ac.cy/~eliasathan/papers/tops20.pdf)
* [audio] [The Virtual World: Embedded Rust part 2 - James Munns](https://anchor.fm/the-virtual-world/episodes/Embedded-Rust-part-2---James-Munns-eooog5)
### Rust Walkthroughs
* [Setting a Rust Executable's Icon in Windows](https://www.anthropicstudios.com/2021/01/05/setting-a-rust-windows-exe-icon/)
* [The Little Book of Rust Books](https://lborb.github.io/book/title-page.html)
* [Rust Design Patterns](https://rust-unofficial.github.io/patterns/)
* [Hecto: Build your own text editor in Rust](https://www.philippflenker.com/hecto/)
* [CLI Shell Completions in Rust](https://dev.to/kbknapp/cli-shell-completions-in-rust-37g1)
* [Dynamically Aligned Types?](https://dev.to/cad97/dynamically-aligned-types-360i)
* [Polishing Rust - Temporary Value Dropped While Borrowed](https://mrtact.medium.com/polishing-rust-42d9131d1c3)
* [Testing Hardware Using Rust Firmware and Rust Based CLI](https://www.jaredwolff.com/testing-hardware-using-rust/)
* [Exposing a Rust Library to Other Languages](https://sixtyfps.io/blog/expose-rust-library-to-other-languages.html)
* [Replacing FastAPI with Rust: Part 3 - Trying Actix](https://dev.to/dbanty/replacing-fastapi-with-rust-part-3-trying-actix-32lp)
* [video] [Learning Rust by following the "Too Many Linked Lists" tutorial (Episode 1)](https://youtu.be/aNv_oqveuCE)
* [video] [Rust Parser and State Machine](https://youtu.be/2aI6bJk76xM)
### Miscellaneous
* [Rust Language Cheat Sheet](https://cheats.rs/)
* [Another Rust-y OS: Theseus joins Redox in pursuit of safer, more resilient systems](https://www.theregister.com/2021/01/14/rust_os_theseus/)
* [video] [OSDI '20 - Redleaf: Isolation and Communication in a Safe Operating System](https://youtu.be/MKjliJWzs6w)
* [video] [Read a paper: Theseus--An OS written in Rust](https://youtu.be/NzmbDU13Ki8)

Number: 374  Date: 2021-01-20 

### Official
* [Inside] [Rustdoc performance improvements](https://blog.rust-lang.org/inside-rust/2021/01/15/rustdoc-performance-improvements.html)
* [Inside] [Changes to the Rustdoc team](https://blog.rust-lang.org/inside-rust/2021/01/19/changes-to-rustdoc-team.html)
### Newsletters
* [This Month in Rust GameDev #17 - December 2020](https://rust-gamedev.github.io/posts/newsletter-017/)
### Project/Tooling Updates
* [IntelliJ Rust Changelog #139](https://intellij-rust.github.io/2021/01/18/changelog-139.html)
* [rust-analyzer Changelog #60](https://rust-analyzer.github.io/thisweek/2021/01/18/changelog-60.html)
* [Knurling-rs Changelog #13](https://ferrous-systems.com/blog/knurling-changelog-13/)
* [This week in Ballista #1](https://ballistacompute.org/thisweek/2021/01/17/this-week-in-ballista-1/)
* [Deno in 2020](https://deno.land/posts/deno-in-2020)
* [async-std v1.9.0](https://github.com/async-rs/async-std/releases/tag/v1.9.0)
* [video] [Penrose 0.2.0 Overview](https://www.youtube.com/watch?v=opLOzofmawI&feature=youtu.be)
### Observations/Thoughts
* [Cryptoxide perf (SHA2 / Blake2)](https://vincenthz.github.io/cryptoxide-performance/)
* [About variadics in Rust](https://gist.github.com/PoignardAzur/aea33f28e2c58ffe1a93b8f8d3c58667)
* [Rust in Production: 1Password](https://serokell.io/blog/rust-in-production-1password)
* [Unconditional loops are unconditionally awesome](https://brson.github.io/2021/01/17/rust-unconditional-loops)
* [Rust is a hard way to make a web API](https://macwright.com/2021/01/15/rust.html)
* [Writing a better Line Iterator in Rust](https://dev.to/mineichen/writing-a-better-line-iterator-in-rust-443m)
* [Implementing cross-process Sanakirja locks](https://pijul.org/posts/2021-01-15-sanakirja-locks/)
* [future::join and const-eval](https://blog.yoshuawuyts.com/future-join-and-const-eval/)
* [I used Rust in production for 6 months! Here's my feedback](https://www.qovery.com/blog/i-use-rust-in-production-for-6-months-heres-my-feedback)
* [video] [Learning Rust with "Too Many Linked Lists" (Episode 2) - Pop & Drop](https://youtu.be/LX9GeWWJRNU)
* [video] [std::process::exit is evil - a Rust bug fixing story](https://youtu.be/zQC8T71Y8e4)
### Rust Walkthroughs
* [OS in Rust: Running our custom kernel on an emulator: Part-5](https://blog.knoldus.com/os-in-rust-running-our-custom-kernel-on-an-emulator-part-5/)
* [Polishing Rust: Boxing and Unboxing Results](https://mrtact.medium.com/polishing-rust-30eeac3c4bf3)
* [Efficient custom shapes in QtQuick with Rust](https://carlschwan.eu/2021/01/20/efficient-custom-shapes-in-qtquick-with-rust/)
* [Scientific Computing in Rust](https://aftix.xyz/home/bacon/)
* [Rust GUI: Introduction a.k.a. the state of Rust GUI libraries (as of January 2021)](https://dev.to/davidedelpapa/rust-gui-introduction-a-k-a-the-state-of-rust-gui-libraries-as-of-january-2021-40gl)
* [How to Fetch a Web API with Rust 🦀](https://dev.to/hb/how-to-fetch-a-web-api-with-rust-1390)
* [Replacing FastAPI with Rust: Part 4 - A Solution](https://dev.to/dbanty/replacing-fastapi-with-rust-part-4-a-solution-2kf9)
* [Getting started with Rust and Redis](https://dev.to/itnext/getting-started-with-rust-and-redis-4h79)
* [How To Write A REST Client In Rust](https://www.lpalmieri.com/posts/how-to-write-a-rest-client-in-rust-with-reqwest-and-wiremock/)
* [video] [Rust live coding - Tower deep dive](https://youtu.be/16sU1q8OeeI)
### Miscellaneous
* [Rust/WebAssembly on AWS Lambda@Edge](https://markentier.tech/posts/2021/01/rust-wasm-on-aws-lambda-edge/)
* [video] [(Live Coding) Zola, a Static Site Generator. Migrating my blog & reviewing Zola's source code.](https://youtu.be/vezfR5ggEkc)

Number: 375  Date: 2021-01-27 

### Official
* [Inside] [Rust & the case of the disappearing stack frames](https://blog.rust-lang.org/inside-rust/2021/01/26/ffi-unwind-longjmp.html)
### Newsletters
### Project/Tooling Updates
* [rust-analyzer Changelog #61](https://rust-analyzer.github.io/thisweek/2021/01/25/changelog-61.html)
* [Performance improvement on front-end generated by rustdoc](https://blog.guillaume-gomez.fr/articles/2021-01-22+Performance+improvement+on+front-end+generated+by+rustdoc)
* [Criterion.rs v0.3.4 and Iai 0.1.0](https://bheisler.github.io/post/criterion-rs-0-3-4/)
* [The RustyHermit Unikernel](https://rust-osdev.com/showcase/rusty-hermit/)
* [Introducing usb-ids.rs](https://blog.yossarian.net/2021/01/21/Introducing-usb-ids-rs)
* ⚡️ [Dotenv-linter v3.0.0: Overview](https://evrone.com/dotenv-linter-v300) 🦀
* 🧮 [An Auto-Increment Crate for Rust](https://jeffa.io/an_auto-increment_crate_for_rust)
### Observations/Thoughts
* [Porting a serverless chatbot from Python to Rust](https://blog.console.dev/porting-a-python-azure-serverless-function-to-rust/)
* [Unsafe Rust: How and when (not) to use it](https://blog.logrocket.com/unsafe-rust-how-and-when-not-to-use-it/)
* [Rust and Go department directories](https://dev.to/mark_saward/rust-and-go-department-directories-bla)
* [Parsing real-world data with Rust: introducing the alias_all attribute in Serde](https://deaddabe.fr/blog/2021/01/27/parsing-real-world-data-with-rust-introducing-the-alias_all-attribute-in-serde/)
### Rust Walkthroughs
* [Wrapping Errors in Rust](https://edgarluque.com/blog/wrapping-errors-in-rust)
* [Implementing Raft's Leader Election in Rust](http://laurocaetano.com/programming/2021/01/23/raft-leader-election-rust/)
* [2048 WASM](https://dev.to/dev_family/2048-wasm-45gc)
* [Implementing an LRU Cache in Rust](https://dev.to/seanchen1991/implementing-an-lru-cache-in-rust-33pp)
* [JSON input validation in Warp](https://dev.to/buinauskas/json-input-validation-in-warp-i5n)
* [Make A Language - Part Nineteen: Code Representations](https://arzg.github.io/lang/19/)
* [Make A Language - Part Twenty: Testing](https://arzg.github.io/lang/20/)
* [How to optimise compilation times with Rust](https://lemmy.ml/post/50089)
* [Automatic flamegraphs for benchmarks with Criterion](https://www.jibbow.com/posts/criterion-flamegraphs/)
* [First time using Yew: A Go game board in just a few lines of Rust.](https://radim.xyz/project/yewban/)
* [ES] [El juego de la vida usando Rust y Iced](https://github.com/irvingfisica/iced_examples/blob/master/Life.md)
### Miscellaneous
* [Are we learning yet?](https://www.arewelearningyet.com/)
* [Microsoft Opens Up Old Win32 APIs to C# and Rust, More Languages to Come](https://visualstudiomagazine.com/articles/2021/01/21/win32-apis.aspx)
* [A fix for the LLVM noalias bug has landed in time for LLVM 12 branches](https://www.reddit.com/r/rust/comments/l4roqk/a_fix_for_the_llvm_noalias_bug_has_landed_in_time/)
* [Dynamic type systems aren't even simpler](https://hisham.hm/2020/01/20/dynamic-type-systems-arent-even-simpler/)
* [Everywhere I go, I miss Rust's \`enum\`s](https://www.reddit.com/r/rust/comments/l594zl/everywhere_i_go_i_miss_rusts_enums/)
* [Open-Source Rust: 24 Awesome Frameworks, Projects, and Libraries](https://serokell.io/blog/open-source-rust)

Number: 376  Date: 2021-02-03 

No official blog posts this week.
### Newsletters
* [RiB Newsletter #20 - Old fashioned chill](https://www.reddit.com/r/rust/comments/lc3tir/rib_newsletter_20_old_fashioned_chill/)
### Project/Tooling Updates
* [rust-analyzer Changelog #62](https://rust-analyzer.github.io/thisweek/2021/02/01/changelog-62.html)
* [IntelliJ Rust Changelog #140](https://intellij-rust.github.io/2021/02/01/changelog-140.html)
* [Llama Rust SDK preview 0.1.3](https://ericsink.com/entries/llama_rust_013.html)
* [Gfx-rs Release of v0.7](https://gfx-rs.github.io/2021/02/02/release-0.7.html)
* [Open-sourcing Datanymizer: in-flight template-driven data anonymization](https://evrone.com/datanymizer)
* [Announcing Step/Dir - Universal Stepper Motor Interface](https://flott-motion.org/news/announcing-step-dir/)
* [Announcing RampMaker - Stepper Motor Acceleration Ramp Generator](https://flott-motion.org/news/announcing-ramp-maker/)
* [Krustlet v0.6.0](https://github.com/deislabs/krustlet/releases/tag/v0.6.0)
### Observations/Thoughts
* [Is Rust a Functional Programming Language?](https://robert.kra.hn/posts/2021-02-03_is-rust-fp/)
* [Rust Collections Case Study: BTreeMap](https://cglab.ca/~abeinges/blah/rust-btree-case/)
* [Saving some allocations](https://vorner.github.io/2021/01/31/saving-some-allocations.html)
* [Bringing Stack Clash Protection to Clang/X86 - the Open Source Way](https://blog.llvm.org/posts/2021-01-05-stack-clash-protection/)
* [Announcing Krator: Build Kubernetes Operators with state machines.](https://deislabs.io/posts/introducing-krator/)
### Rust Walkthroughs
* [Returning Rust Iterators](https://depth-first.com/articles/2020/06/22/returning-rust-iterators/)
* [How to Read Rust Functions, Part 1](https://www.possiblerust.com/guide/how-to-read-rust-functions-part-1)
* [Parsing PDF Documents in Rust](https://adventures.michaelfbryan.com/posts/parsing-pdfs-in-rust/?utm_source=reddit&utm_medium=social&utm_campaign=parsing-pdf-documents)
* [Building and deploying Rust utilities](https://robert.kra.hn/posts/2021-02-01_cross-compile-rust/)
* [Learning to Fly: Let's create a simulation in Rust! (pt 2)](https://pwy.io/en/posts/learning-to-fly-pt2/)
* [Rust made my open source project 1000x faster](https://www.reddit.com/r/rust/comments/lazq0i/rust_made_my_open_source_project_1000x_faster/)
* [Introducing Drogue Device](https://blog.drogue.io/introducing-drogue-device/)
* [3 Things to Try When You Can't Make A Trait Object](https://www.possiblerust.com/pattern/3-things-to-try-when-you-can-t-make-a-trait-object)
* [Making concurrency fearless with Rust (for C++ developers)](https://radekvit.medium.com/making-concurrency-fearless-with-rust-for-c-developers-d5d8da50a452)
* [Exploring WebSocket with Rust and Tide](https://javierviola.com/post/exploring-websocket-with-rust-and-tide/)
* [Macros in Rust: A tutorial with examples](https://blog.logrocket.com/macros-in-rust-a-tutorial-with-examples/)
* [PL] [CrabbyBird #5 Obsługa kolizji](https://postacnormalna.pl/crabbybird-5-obsluga-kolizji/)
### Miscellaneous
* [RustBelt: Securing the Foundations of the Rust Programming Language](https://people.mpi-sws.org/~dreyer/papers/rustbelt/paper.pdf)
* [Polymorphisation: Improving Rust compilation times through intelligent monomorphisation](https://davidtw.co/media/masters_dissertation.pdf)
* [A Memory Safe TLS Module for the Apache HTTP Server](https://www.abetterinternet.org/post/memory-safe-tls-apache/)
* [Chats with James: 006 - Bryan Cantrill](https://jamesmunns.com/podcast/006-bryan/)
* [Long range networking with LoRa: an overview featuring a Rust modem driver](https://tweedegolf.nl/blog/51/long-range-networking-with-lora-an-overview)

Number: 377  Date: 2021-02-10 

### Official
* [Foundation] [Hello World!](https://foundation.rust-lang.org/posts/2021-02-08-hello-world/)
* [Inside] [1.50.0 pre-release testing](https://blog.rust-lang.org/inside-rust/2021/02/09/1.50.0-prerelease.html)
### Newsletters
* [This Month in Rust GameDev #18 - January 2021](https://rust-gamedev.github.io/posts/newsletter-018/)
* [This Month in Rust OSDev (January 2021)](https://rust-osdev.com/this-month/2021-01/)
### Project/Tooling Updates
* [rust-analyzer Changelog #63](https://rust-analyzer.github.io/thisweek/2021/02/08/changelog-63.html)
* [Launching wasm.rs: a collection of crates, a community](https://yrashk.medium.com/launching-wasm-rs-a-collection-of-crates-a-community-4344d2ba75b3)
* [A Memory Safe TLS Module for the Apache HTTP Server](https://www.abetterinternet.org/post/memory-safe-tls-apache/)
### Observations/Thoughts
* [Benchmarking Tokio Tasks and Goroutines](https://www.reddit.com/r/rust/comments/lg0a7b/benchmarking_tokio_tasks_and_goroutines/)
* [A Better Rust Profiler](https://matklad.github.io/2021/02/10/a-better-profiler.html)
* [An unsafe tour of Rust's Send and Sync](https://nyanpasu64.github.io/blog/an-unsafe-tour-of-rust-s-send-and-sync/)
* [Improving texture atlas allocation in WebRender](https://nical.github.io/posts/etagere.html)
### Rust Walkthroughs
* [Async Rust: Futures, Tasks, Wakers; Oh My!](https://msarmi9.github.io/posts/async-rust/)
* [Rust for Haskell Programmers!](https://mmhaskell.com/rust)
* [Rust CLI Game of Life tutorial - Part 1](https://dev.to/jbarszczewski/rust-cli-game-of-life-tutorial-part-1-57pp)
* [Where everything went wrong...](https://msirringhaus.github.io/Where-everything-went-wrong/)
* [Rust for Clojurists](https://gist.github.com/oakes/4af1023b6c5162c6f8f0)
* [ES] [El formato RON: Rusty Object Notation](https://blog.adrianistan.eu/formato-ron-rusty-object-notation)
* [video] [1Password Developer Fireside Chat: Introduction to Rust Macros](https://youtu.be/Lh262L63asA)
* [video] [Dynamic vs Static Dispatch in Rust](https://youtu.be/tM2r9HD4ivQ)
### Miscellaneous
* [Congratulations, Rustaceans, on the creation of the Rust Foundation!](https://aws.amazon.com/blogs/opensource/congratulations-rustaceans-on-the-creation-of-the-rust-foundation/)
* [Microsoft joins Rust Foundation](https://cloudblogs.microsoft.com/opensource/2021/02/08/microsoft-joins-rust-foundation/)
* [Google joins the Rust Foundation](https://opensource.googleblog.com/2021/02/google-joins-rust-foundation.html)
* [Mozilla Welcomes the Rust Foundation](https://blog.mozilla.org/blog/2021/02/08/mozilla-welcomes-the-rust-foundation/)
* [Trusted Programming - Our Rust Mission at Huawei](https://trusted-programming.github.io/2021-02-07/index.html)
* [YSK: VSCode's most recent update fixed a quirk in Rust workflows](https://www.reddit.com/r/rust/comments/lgccv5/ysk_vscodes_most_recent_update_fixed_a_quirk_in/)
* [curl supports rustls](https://daniel.haxx.se/blog/2021/02/09/curl-supports-rustls/)
* [Architecting Artichoke Ruby: A Modular Ruby implementation written in Rust](https://github.com/artichoke/artichoke/blob/21045d8f1086c669dd428a3b5bdcc4a58e13acec/ARCHITECTURE.md)
* [video] [Interview with Ashley Williams, Rust Foundation Interim Executive Director (Part 1)](https://youtu.be/h-LoPr5553o)

Number: 378  Date: 2021-02-17 

No newsletters this week.
### Official
* [Announcing Rust 1.50.0](https://blog.rust-lang.org/2021/02/11/Rust-1.50.0.html)
### Project/Tooling Updates
* [IntelliJ Rust changelog #141](https://intellij-rust.github.io/2021/02/15/changelog-141.html)
* [rust-analyzer changelog #64](https://rust-analyzer.github.io/thisweek/2021/02/15/changelog-64.html)
* [A big release for relm](https://relm.antoyo.xyz/big-release/)
### Observations/Thoughts
* [The XDG base directory specification and Rust](https://blog.liw.fi/posts/2021/02/14/xdg-base-dirs-rust/)
* [Zero dependency images (of chaos) in Rust](https://state.smerity.com/smerity/state/01EYB6YQ5T2KFSC1PF55A3B8DG)
* [Examples of declarative style in Rust](https://radekvit.medium.com/examples-of-declarative-style-in-rust-9fae89c0fea)
* [Rust 2030 Christmas list: Better cfg](https://gist.github.com/PoignardAzur/8038f5ed7dc8d00e3e9472aca57fb35c)
* [For the Love of Macros](https://matklad.github.io/2021/02/14/for-the-love-of-macros.html)
* [The Tokio Upgrade from 0.2 to 1.x](https://fly.io/blog/the-tokio-1-x-upgrade/)
* [Cranelift, Part 2: Compiler Efficiency, CFGs, and a Branch Peephole Optimizer](https://cfallin.org/blog/2021/01/22/cranelift-isel-2/)
* [audio] [Building with Rust: Luca Palmieri on TrueLayer and Zero to Production](https://anchor.fm/building-with-rust/episodes/Building-with-Rust-Luca-Palmieri-on-TrueLayer-and-Zero-to-Production-eq9rqs)
* [audio] [Chats with James 008 - Yoshua Wuyts](https://jamesmunns.com/podcast/008-yosh/)
* [video] [Rust 1.50 Patch Review](https://www.youtube.com/watch?v=C7BTIdkWreI&feature=youtu.be)
### Rust Walkthroughs
* [Actors with Tokio](https://ryhl.io/blog/actors-with-tokio/)
* [Building a microservice with Rust](https://medium.com/tenable-techblog/building-a-microservice-with-rust-23a4de6e5e14)
* [Rust is cool - Enums](https://thatgeoguy.ca/blog/2021/02/15/rust-is-cool-enums/)
* [Rust CLI Game of Life tutorial - Part 2](https://dev.to/jbarszczewski/rust-cli-game-of-life-tutorial-part-2-16j3)
* [Calling Rust from a Cloudflare Worker](https://dev.to/jldec/calling-rust-from-a-cloudflare-worker-17b4)
* [Validating JSON input with Rust web services](https://dev.to/vinted/validating-json-input-in-rust-web-services-5gp0)
* [What would SQLite look like if written in Rust? -- Part 1](https://dev.to/joaoh82/what-would-sqlite-look-like-if-written-in-rust-part-1-2np4)
* [Generalizing over Generics in Rust (Part 1) - AKA Higher Kinded Types in Rust](https://rustyyato.github.io/type/system,type/families/2021/02/15/Type-Families-1.html)
* [Procedural Macros: The Basics](https://blog.turbo.fish/proc-macro-basics/)
* [Building an OpenStreetMap app in Rust, Part II](https://blogg.bekk.no/building-an-openstreetmap-app-in-rust-part-ii-933ca8d0c48a)
* [Look, Ma! No JS! - Compiling Rust to WebAssembly](https://www.novatec-gmbh.de/en/blog/look-ma-no-js-compiling-rust-to-webassembly/)
* [Simple ray tracer written in Rust from scratch](https://github.com/dranikpg/simple-rays)
* [Short Circuit Sum in Rust](https://www.fpcomplete.com/blog/short-circuit-sum-rust/)
* [Zero to Production in Rust, Part 7.1 - Skeleton And Principles For A Maintainable Test Suite](https://www.lpalmieri.com/posts/skeleton-and-principles-for-a-maintainable-test-suite/)
* [CCSS Devclub Rust Workshop](https://www.notion.so/CCSS-Devclub-Rust-Workshop-dccad2c1119d4af7bf78f3d3b4797603)
* [video] [Graphs in Rust: Let's Build a Maze!](https://youtu.be/UEAg4qCALb8)
### Miscellaneous
* [Cleora - an ultra fast graph embedding tool written in Rust](https://github.com/Synerise/cleora)
* [Cost-based query optimizations in multithreaded environments](https://vertexclique.com/cost-based-query-optimizations/)
* [Writing our own Cheat Engine: Exact Value scanning](https://lonami.dev/blog/woce-2/)

Number: 379  Date: 2021-02-24 

No newsletters or official blog posts this week.
### Project/Tooling Updates
* [MoonZoon - New Rust fullstack framework](https://moonzoon.rs)
* [rust-analyzer Changelog #65](https://rust-analyzer.github.io/thisweek/2021/02/22/changelog-65.html)
* [Knurling-rs changelog #17](https://ferrous-systems.com/blog/knurling-changelog-17/)
### Observations/Thoughts
* [Rust for web development: 2 years later](https://kerkour.com/blog/rust-for-web-development-2-years-later/)
* [Integrating Rust and C++ in Firefox](https://manishearth.github.io/blog/2021/02/22/integrating-rust-and-c-plus-plus-in-firefox/)
* [Building a telnet chat server with Rust and Lunatic](https://dev.to/bkolobara/how-i-built-a-telnet-chat-server-in-2021-with-webassembly-2711)
* [Against Packaging Rust Crates](https://fy.blackhats.net.au/blog/html/2021/02/16/against_packaging_rust_crates.html)
* [Why building a front-end framework in Rust is hard](https://lik.ai/blog/why-building-a-front-end-framework-in-rust-is-hard)
* [Oxidizing Kraken](https://blog.kraken.com/post/7964/oxidizing-kraken/?)
* [Maybe We Can Have Nice Things](https://noncombatant.org/2021/02/16/maybe-we-can-have-nice-things/)
* [Three Things I Miss About Rust](https://bennett.dev/)
* [Storages: an alternative to allocators](https://www.reddit.com/r/rust/comments/lp0i5r/storages_an_alternative_to_allocators/)
### Rust Walkthroughs
* [Rust ownership, the hard way](https://chrismorgan.info/blog/rust-ownership-the-hard-way/)
* [Handling Unix Kill Signals in Rust](https://dev.to/talzvon/handling-unix-kill-signals-in-rust-55g6)
* [Replacing FastAPI with Rust: Part 5 - Rocket 0.5](https://dev.to/dbanty/replacing-fastapi-with-rust-part-5-rocket-0-5-3kb3)
* [Running ML models in a game (and in Wasm!)](https://dev.to/mockersf/running-ml-models-in-a-game-and-in-wasm-12i2)
* [What would SQLite look like if written in Rust? - Part 2](https://dev.to/joaoh82/what-would-sqlite-look-like-if-written-in-rust-part-2-4g66)
* [A primer on code generation in Cranelift](https://blog.benj.me/2021/02/17/cranelift-codegen-primer/)
* [Testing a Hardware Abstraction Layer (HAL)](https://ferrous-systems.com/blog/defmt-test-hal/)
* [Cross Compiling Rust GTK Projects for Windows](https://nivethan.dev/devlog/cross-compiling-rust-gtk-projects-for-windows.html)
* [Procedural Macros: A simple derive macro](https://blog.turbo.fish/proc-macro-simple-derive/)
* [Building an OpenStreetMap app in Rust, Part III](https://blogg.bekk.no/building-an-openstreetmap-app-in-rust-part-iii-ab9ad4b83bd8)
* [Generalizing over Generics in Rust (Part 1.5): Mechanisms](https://rustyyato.github.io/type/system,type/families/2021/02/22/Type-Families-1_5.html)
* [Macros in Rust: A tutorial with examples](https://blog.logrocket.com/macros-in-rust-a-tutorial-with-examples/)
* [ES] [Pipelines en Rust(II)](https://yorodm.is-a.dev/blog/rust-pipeline-pattern-ii/)
* [video] [Rust for Windows](https://youtu.be/LajquCjHXK4)
* [video] [Crust of Rust: Subtyping and Variance](https://youtu.be/iVYWDIW71jk)
* [video] [Learning Rust: Web Server with Actix Web](https://youtu.be/PMa2m0Fe-Q4)
* [video] [series] [Rust For Beginners - Watch me code the Rustlings Tutorial](https://youtube.com/playlist?list=PLauX9TuJ8sfyaLPZ1udS3zS_V9YXdsbtc)
* [video] [series] [Easy Rust - learn to program in Rust with simple English](https://youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk)
### Miscellaneous
* [Python cryptography, Rust, and Gentoo](https://lwn.net/Articles/845535/)
* [Mitigating Memory Safety Issues in Open Source Software](https://security.googleblog.com/2021/02/mitigating-memory-safety-issues-in-open.html)
* [matklad @ NEAR](https://matklad.github.io/2021/02/15/NEAR.html)
* [Application-wide panic handling](https://domwillia.ms/panik/)
* [Benchmarking low-level I/O: C, C++, Rust, Golang, Java, Python](https://medium.com/star-gazers/benchmarking-low-level-i-o-c-c-rust-golang-java-python-9a0d505f85f7)
* [video] [Ask the Expert: Rust at Microsoft](https://youtu.be/1uAsA1hm52I)
* [video] [AWS re:Invent 2020: Next-gen networking infrastructure with Rust and Tokio](https://youtu.be/MZyleK8elPk)
* [video] [Interview Part 2/2 with Ashley Williams, Rust Foundation Interim Executive Director](https://youtu.be/eFQVxQsYcJ8)

Number: 380  Date: 2021-03-03 

No newsletters this week.
### Official
* [Const generics MVP hits beta!](https://blog.rust-lang.org/2021/02/26/const-generics-mvp-beta.html)
* [Inside] [Lang team March update](https://blog.rust-lang.org/inside-rust/2021/03/03/lang-team-mar-update.html)
### Project/Tooling Updates
* [IntelliJ Rust Changelog #142](https://intellij-rust.github.io/2021/03/01/changelog-142.html)
* [rust-analyzer changelog #66](https://rust-analyzer.github.io/thisweek/2021/03/01/changelog-66.html)
* [Knurling-rs changelog #18](https://ferrous-systems.com/blog/knurling-changelog-18/)
* [Last Month in Flott - March 2021](https://flott-motion.org/news/last-month-in-flott-march-2021/)
* [RampMaker 0.2 - Stepper Motor Acceleration Ramp Generator](https://flott-motion.org/news/ramp-maker-0-2/)
### Observations/Thoughts
* [Why we built the core auth library in Rust (interview with CTO of Oso)](https://console.dev/qa/oso-sam-scott/)
* [Data Manipulation: Pandas vs Rust](https://able.bio/haixuanTao/data-manipulation-pandas-vs-rust--1d70e7fc)
* [Evolution of Kube](https://clux.github.io/probes/post/2021-02-28-kube-evolution/)
* [Temporal RDO update optimization](https://dev.to/luzero/temporal-rdo-update-optimization-2pf1)
* [Introducing The Calypso Chronicles](https://dev.to/thepuzzlemaker/introducing-the-calypso-chronicles-1ff8)
* [Rust: Beware of Escape Sequences\n](https://d3lm.medium.com/rust-beware-of-escape-sequences-85ec90e9e243#ee0e-58229fc84d02)
* [Introducing Rustybot (part 3 of n)](https://objectdisoriented.evokewonder.com/posts/introducing-rustybot-part-3/)
* [Delete Cargo Integration Tests](https://matklad.github.io/2021/02/27/delete-cargo-integration-tests.html)
### Rust Walkthroughs
* [C++ to Rust - or how to render your mindset](https://jduchniewicz.com/posts/2021/02/c-to-rust-or-how-to-render-your-mindset/)
* [Generic `impl` blocks are kinda like macros...](https://dev.to/somedood/generic-impl-blocks-are-kinda-like-macros-1aa0)
* [Make a Back-End Number Guessing Game with Rust](https://dev.to/xinnks/make-a-back-end-number-guessing-game-with-rust-1hkj)
* [Captures in closures and async blocks](https://www.fpcomplete.com/blog/captures-closures-async/)
* [Testing a driver crate](https://ferrous-systems.com/blog/test-driver-crate/)
* [Using Rust for AWS Lambdas](https://beanseverywhere.xyz/blog/rust-lambda)
* [Always-On Benchmarking in Rust](https://medium.com/edge-node-engineering/always-on-benchmarking-in-rust-d23f2bac1c1d)
* [Building an OpenStreetMap app in Rust, Part IV](https://blogg.bekk.no/building-an-openstreetmap-app-in-rust-part-iv-d82ebc245381)
* [Solving Advent of Code 2020 in under a second](https://timvisee.com/blog/solving-aoc-2020-in-under-a-second/)
* [The Case for the Typestate Pattern - Introducing Algebraic Data Types](https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate-pattern-introducing-algebraic-data-types/)
* [DE] [Weniger Frust mit Rust](https://www.golem.de/news/programmiersprachen-weniger-frust-mit-rust-2102-154243.html)
* [video] [Learning Rust: Procedural Macros](https://youtu.be/9IbYBl48eTQ)
* [video] [Rust proxy server with Warp and Hyper](https://youtu.be/eIllaNZisiU)
### Miscellaneous
* [Ferrocene Part 3: The Road to Rust in mission- and safety-critical](https://ferrous-systems.com/blog/ferrocene-update-three-the-road/)
* [How our AWS Rust team will contribute to Rust's future successes](https://aws.amazon.com/blogs/opensource/how-our-aws-rust-team-will-contribute-to-rusts-future-successes/)
* [Librsvg, Rust, and non-mainstream architectures](https://people.gnome.org/~federico/blog/librsvg-rust-and-non-mainstream-architectures.html)

Number: 381  Date: 2021-03-10 

### Official
* [Planning the Rust 2021 Edition](https://blog.rust-lang.org/inside-rust/2021/03/04/planning-rust-2021.html)
### Newsletters
* [This Month in Rust GameDev #19 - February 2021](https://rust-gamedev.github.io/posts/newsletter-019/)
* [This Month in Rust OSDev (February 2021)](https://rust-osdev.com/this-month/2021-02/)
* [RiB Newsletter #21 - More Rust and blockchains](https://www.reddit.com/r/rust/comments/lxdw8j/rib_newsletter_21_more_rust_and_blockchains/)
### Project/Tooling Updates
* [rust-analyzer Changelog #67](https://rust-analyzer.github.io/thisweek/2021/03/08/changelog-67.html)
* [rust-gpu v0.3](https://github.com/EmbarkStudios/rust-gpu/releases/tag/v0.3.0)
* [cargo-generate 0.6.0](https://github.com/cargo-generate/cargo-generate/releases/tag/v0.6.0)
* [Automatically generate APIs for datasets using Rust, Arrow and Datafusion](https://roapi.github.io/docs/index.html)
### Observations/Thoughts
* [Serverless Rust Testing](https://www.peakscale.com/serverless-rust/)
* [Rust's Type System is Turing-Complete](https://sdleffler.github.io/RustTypeSystemTuringComplete/)
* [Why I rewrote my Rust keyboard firmware in Zig: consistency, mastery, and fun](https://kevinlynagh.com/rust-zig/)
* [Calling a private Rust function from outside of its module](https://tim.mcnamara.nz/post/644942576528523264/calling-a-private-rust-function-from-outside)
* [Safe, Flexible Aliasing with Deferred Borrows](https://cfallin.org/pubs/ecoop2020_defborrow.pdf)
* [Evaluating Memory Models for Graph-Like Data Structures in the Rust Programming Language: Performance and Usability](http://www.diva-portal.org/smash/record.jsf?pid=diva2%3A1463648&dswid=1332)
* [Rusts Universes](https://aloso.github.io/2021/03/10/rusts-universes.html)
* [How I significantly improved Giganotes app performance using Rust](https://www.reddit.com/r/rust/comments/m14agf/how_i_significantly_improved_giganotes_app/)
### Rust Walkthroughs
* [OS in Rust: Incorporate VGA buffer: Part-6](https://blog.knoldus.com/os-in-rust-incorporate-vga-buffer-part-6/)
* [Writing a 3D Shooter using rg3d - #1 - Character Controller](https://rg3d.rs/tutorials/2021/03/05/tutorial1.html)
* [Writing a 3D Shooter using rg3d - #2 - Weapons](https://rg3d.rs/tutorials/2021/03/09/tutorial2.html)
* [Writing Pong in Rust for my OS Written in Rust](https://blog.stephenmarz.com/2021/02/22/writing-pong-in-rust/)
* [Replacing FastAPI with Rust: Part 6 - AWS Lambda](https://dev.to/dbanty/replacing-fastapi-with-rust-part-6-aws-lambda-inm)
* [Creating an Iterator in Rust](https://aloso.github.io/2021/03/09/creating-an-iterator)
* [Building an OpenStreetMap app in Rust, Part V](https://blogg.bekk.no/building-an-openstreetmap-app-in-rust-part-v-f14831e13e61)
* [video] [Learning Rust: Structs and Traits](https://youtu.be/tYfA5rjrhqk)
* [video] [Answers to StackOverflow's top Rust programming questions explained](https://youtu.be/Flf4ezLWw1E)
* [video] [(Live Coding) Learning Timely Dataflow](https://youtu.be/z2m1Y4nj7s8)
* [FA] [video] [Rust in Farsi ツ](https://www.youtube.com/channel/UCIXThmX_uAp2cJTR-hTjdcA)
### Papers and Research Projects
* [Creusot is a tool for deductive verification of Rust code](https://github.com/xldenis/creusot)
* [egg, a Rust library for e-graphs and equality saturation](https://egraphs-good.github.io/)
### Miscellaneous
* [Debian running on Rust coreutils](https://sylvestre.ledru.info/blog/2021/03/09/debian-running-on-rust-coreutils)
* [A friend and I made pipes-rs, a Rust clone of pipes.sh](https://www.reddit.com/r/rust/comments/lxil6d/a_friend_and_i_made_pipesrs_a_rust_clone_of/)
* [Half of curl's vulnerabilities are C mistakes](https://daniel.haxx.se/blog/2021/03/09/half-of-curls-vulnerabilities-are-c-mistakes/)
* [video] [USENIX Enigma 2021 - Quantifying Memory Unsafety and Reactions to It](https://youtu.be/drfXNB6p6nI)

Number: 382  Date: 2021-03-17 

### Official
*No Official Blog Posts this week*
### Newsletters
*No Newsletters this week*
### Project/Tooling Updates
* [MiniWASM - A minimalist Rust WebAssembly project template](https://github.com/thedjinn/MiniWASM)
* [Stepper 0.5 (formerly Step/Dir) - Universal Stepper Motor Interface](https://flott-motion.org/news/stepper-0-5/)
* [Rust Analyzer Changelog #68](https://rust-analyzer.github.io/thisweek/2021/03/15/changelog-68.html)
* [IntelliJ Rust Changelog #143](https://intellij-rust.github.io/2021/03/16/changelog-143.html)
### Observations/Thoughts
* [Why the Starship shell prompt is built in Rust (interview with project creator)](https://console.dev/qa/starship-matan-kushner/)
* [Rust vs. Go: Why They’re Better Together](https://thenewstack.io/rust-vs-go-why-theyre-better-together/?s=09)
* [Cranelift, Part 3: Correctness in Register Allocation](https://cfallin.org/blog/2021/03/15/cranelift-isel-3/)
* [Making Great Docs with Rustdoc](https://www.tangramvision.com/blog/making-great-docs-with-rustdoc)
* [Writing a Postgres SQL Pretty Printer in Rust: Part 1](https://blog.urth.org/2021/03/14/writing-a-postgres-sql-pretty-printer-in-rust-part-1/)
* [Data Manipulation: Polars vs Rust](https://able.bio/haixuanTao/data-manipulation-polars-vs-rust--3def44c8)
### Rust Walkthroughs
* [OS in Rust: Incorporate VGA buffer: Part-7](https://blog.knoldus.com/os-in-rust-incorporate-vga-buffer-part-7/)
* [Rust Koans](https://github.com/crazymykl/rust-koans)
* [How to send emails with Rust](https://kerkour.com/blog/rust-send-email/)
* [Writing Pong in Rust for my OS Written in Rust](https://blog.stephenmarz.com/2021/02/22/writing-pong-in-rust/)
* [Arenas in Rust](https://manishearth.github.io/blog/2021/03/15/arenas-in-rust/)
* [Zero Downtime Deployments](https://www.lpalmieri.com/posts/zero-downtime-deployments/)
* [Deploy A Rust Website on Heroku](https://dev.to/xinnks/deploy-a-rust-website-on-heroku-1l45)
* [One enum to rule them all](https://www.jakobmeier.ch/blogging/Enums.html)
* [Writing a 3D Shooter using rg3d - #3 - Bots, AI](https://rg3d.rs/tutorials/2021/03/11/tutorial3.html)
* [Developing High Performance Apache Cassandra™ Applications in Rust (Part 1)](https://www.datastax.com/blog/2021/03/developing-high-performance-apache-cassandra-applications-rust-part-1)
* [Strings in Rust](https://bes.github.io/blog/rust-strings/)
* [Rust - Reqwest examples](https://dev.to/pintuch/rust-reqwest-examples-10ff)
* [libp2p tutorial: Build a peer-to-peer app in Rust](https://blog.logrocket.com/libp2p-tutorial-build-a-peer-to-peer-app-in-rust/)
* [video] [Rust for Beginners - Watch me code the Rustlings Tutorial](https://www.youtube.com/playlist?list=PLauX9TuJ8sfyaLPZ1udS3zS_V9YXdsbtc)
* [video] [Crust of Rust: The Drop Check (live edition)](https://www.youtube.com/watch?v=Das3XSWo1GU)
### Papers and Research Projects
**No Papers and Research Projects This Week*
### Miscellaneous
* [rkyv is faster than {bincode, capnp, cbor, flatbuffers, postcard, prost, serde_json}](https://davidkoloski.me/blog/rkyv-is-faster-than/)
* [100ms delays with Rust on Lambda](https://www.peakscale.com/100ms-gotcha/)
* [Speed of Rust vs C](https://kornel.ski/rust-c-speed)
* [Rust Playground At Your Fingertips](https://www.greyblake.com/blog/2021-03-12-rust-playground-at-your-fingertips/)
* [totally_safe_transmute, line-by-line](https://blog.yossarian.net/2021/03/16/totally_safe_transmute-line-by-line)
* [Rust Graphics Crates](https://github.com/ocboogie/rust-graphics-crates)
* [C++ to Rust - or how to render your mindset](https://jduchniewicz.com/posts/2021/02/c-to-rust-or-how-to-render-your-mindset/#introduction)
* [Paid Online Research: Rust Programmers’ Experience and Challenges](https://www.personal.psu.edu/suz305/recruitment-twir.html)

Number: 383  Date: 2021-03-24 

### Official
* [Building a shared vision for Async Rust](https://blog.rust-lang.org/2021/03/18/async-vision-doc.html)
* [Inside] [1.51.0 pre-release testing](https://blog.rust-lang.org/inside-rust/2021/03/23/1.51.0-prerelease.html)
* [Foundation] [Introducing Bobby Holley](https://foundation.rust-lang.org/posts/2021-03-18-introducing-bobby-holley/)
* [Foundation] [Introducing Tyler Mandry](https://foundation.rust-lang.org/posts/2021-03-18-introducing-tyler-mandry/)
### Newsletters
### Project/Tooling Updates
* [rust-analyzer Changelog #69](https://rust-analyzer.github.io/thisweek/2021/03/22/changelog-69.html)
### Observations/Thoughts
* [The biggest threat to Rust's sustainability](https://kerkour.com/blog/the-biggest-threat-to-rust-sustainability/)
* [Safe Systems Programming in Rust](https://cacm.acm.org/magazines/2021/4/251364-safe-systems-programming-in-rust/fulltext)
* [The GPIO war: macro bunkers for typestate explosions](https://www.ecorax.net/macro-bunker-1/)
* [A look back at asynchronous Rust](https://tomaka.medium.com/a-look-back-at-asynchronous-rust-d54d63934a1c)
* [Rust as an App Language](https://www.ikiapps.com/programming/2019/07/26/is-rust-good-for-apps)
* [How often does Rust change?](https://steveklabnik.com/writing/how-often-does-rust-change)
* [Serving a single file over HTTP with Rust and Go](https://vadosware.io/post/serving-a-single-file-over-http-with-rust-and-go/)
* [The Case for the Typestate Pattern - The Typestate Pattern itself](https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate-pattern-the-typestate-pattern-itself/)
* [ZH] [Rust in Embedded World](https://zhuanlan.zhihu.com/p/352945545)
* [video] [Cheaply writing a fast interpreter - Neil Mitchell](https://youtu.be/V8dnIw3amLA)
### Rust Walkthroughs
* [Introduction to Apache Arrow with Rust](https://bit.ly/apache-arrow-with-rust)
* [How to execute shellcodes from memory in Rust](https://kerkour.com/blog/rust-execute-from-memory/)
* [Beginner's Guide to Rust Pattern Matching](https://doma-dev.medium.com/pattern-matching-in-rust-and-other-imperative-languages-7cf1c6abf4a1)
* [Writing a PostgreSQL Pretty Printer in Rust: Part 1.5](https://blog.urth.org/2021/03/21/writing-a-postgres-sql-pretty-printer-in-rust-part-1-5/)
* [Calling .NET APIs from Rust](https://ericsink.com/entries/lousygrep.html)
* [The magical applications of Zero-Sized Types in Rust](https://www.hardmo.de/article/2021-03-14-zst-proof-types.md)
* [Rust and Rocket - Zero to Deploy](https://dev.to/alexmercedcoder/rust-rocket-zero-to-deploy-578o)
* [Learning to Fly: Let's simulate evolution in Rust! (pt 3)](https://pwy.io/en/posts/learning-to-fly-pt3/)
* [Building an OpenStreetMap app in Rust, Part VI](https://blogg.bekk.no/building-an-openstreetmap-app-in-rust-part-vi-8cfc8c3f7798)
* [Tutorial: Writing a tiny Entity Component System in Rust](https://ianjk.com/ecs-in-rust/)
* [Implementing RAII guards in Rust](https://aloso.github.io/2021/03/18/raii-guards.html)
* [JP] [[TECH] Actix web で HttpOnly な Cookie を設定する 🍪](https://dev.to/nikaera/tech-actix-web-httponly-cookie-182)
* [video] [The four-part "Overview of the Rust Programming Language" for beginners is now complete](https://www.youtube.com/watch?v=gesNaLkUJeA&list=PLP2yfE2-FXdQmXLvrQ5QN64enbF_KCYQW)
### Papers and Research Projects
_No Papers or Research Projects this week_
### Miscellaneous
* [Streaming using Bastion & Kafka - near consumer native correlation](https://vertexclique.com/streaming-with-bastion-and-kafka/)
* [Performance comparison: counting words in Python, Go, C++, C, AWK, Forth, and Rust](https://benhoyt.com/writings/count-words/)
* [Linus Torvalds on where Rust will fit into Linux](https://www.zdnet.com/article/linus-torvalds-on-where-rust-will-fit-into-linux/)
* [Rust: integrating LLVM source-base code coverage with GitLab](https://www.collabora.com/news-and-blog/blog/2021/03/24/rust-integrating-llvm-source-base-code-coverage-with-gitlab/)

Number: 384  Date: 2021-03-31 

No newsletters this week.
### Official
* [Announcing Rust 1.51.0](https://blog.rust-lang.org/2021/03/25/Rust-1.51.0.html)
* [Foundation] [Introducing Mark Rousskov](https://foundation.rust-lang.org/posts/2021-03-25-introducing-mark-rousskov/)
* [Foundation] [Introducing Nell Shamrell-Harrington](https://foundation.rust-lang.org/posts/2021-03-25-introducing-nell-shamrell-harrington/)
### Project/Tooling Updates
* [rust-analyzer changelog #70](https://rust-analyzer.github.io/thisweek/2021/03/29/changelog-70.html)
* [IntelliJ Rust Changelog #144](https://intellij-rust.github.io/2021/03/29/changelog-144.html)
* [Knurling-rs Financial Update and Call for Funding](https://ferrous-systems.com/blog/knurling-financial-update/)
* [Ockam | End-to-end encrypted messaging and mutual authentication between distributed applications](https://github.com/ockam-network/ockam)
* [Announcing the Deno Company](https://deno.com/blog/the-deno-company)
### Observations/Thoughts
* [Using Rust to corrode insane Python run-times](https://www.vortexa.com/insight/using-rust-to-corrode-insane-python-run-times)
* [The current state of Rust web frameworks](https://blog.logrocket.com/the-current-state-of-rust-web-frameworks/)
* [GhostCell: Separating Permissions from Data in Rust](http://plv.mpi-sws.org/rustbelt/ghostcell/)
* [Using const generics in slipstream](https://vorner.github.io/2021/03/28/const-generic-slipstreem.html)
* [Rust iterators tips and tricks](https://robinmoussu.gitlab.io/blog/post/2021-03-25_rust_iterators_tips_and_tricks/)
### Rust Walkthroughs
* [Pin and suffering](https://fasterthanli.me/articles/pin-and-suffering)
* [Embedding Rust Into Zephyr Firmware using C-bindgen](https://www.jaredwolff.com/embedding-rust-into-zephyr-using-cbindgen/)
* [Parser combinators in Rust](https://doma.dev/blog/parsing-stuff-in-rust/)
* [Grids in Rust, part 2: const generics](https://blog.adamchalmers.com/grids-2/)
* [Ergonomic error handling with Rust](https://dev.to/senyeezus/ergonomic-error-handling-with-rust-13bj)
* [Implementing SHA2 (256/512) algorithm with Rust const generics](https://dev.to/dandyvica/implementing-sha2-256-512-algorithm-with-rust-const-generics-5ap)
* [Analisando alocações de memória em Rust utilizando GNU Debugger](https://dev.to/ignaciojvig/analisando-alocacoes-de-memoria-em-rust-utilizando-gnu-debugger-34kb)
* [Testing an embedded application](https://ferrous-systems.com/blog/test-embedded-app/)
* [Using Const Generics To Model An Electronics Graph](https://mkhan45.github.io/2021/03/28/Using-const-generics-to-model-an-electronics-graph.html)
* [Rust's Module System Explained](https://aloso.github.io/2021/03/28/module-system.html)
* [series] [Working with the trust-dns-resolver crate](https://dev.to/basman/series/11934)
* [video] [Safer Rust: Program Verification with Creusot](https://youtu.be/BPt987BRdDw)
### Miscellaneous
* [Linus Torvalds weighs in on Rust language in the Linux kernel](https://arstechnica.com/gadgets/2021/03/linus-torvalds-weighs-in-on-rust-language-in-the-linux-kernel/)
* [Ownership Concept Diagram](https://www.reddit.com/r/rust/comments/mgh9n9/ownership_concept_diagram/)