https://readrust.net/Mon, 16 Oct 2023 02:53:19 +0000ad5f1111-0d73-4e39-b196-59820eed781cMon, 16 Oct 2023 02:53:19 +0000https://without.boats/blog/why-async-rust/Saoirse065deb27-4c94-48dd-8300-dd407753efc0Thu, 9 Mar 2023 00:17:25 +0000https://without.boats/blog/the-registers-of-rust/Saoirse7d1d0b2a-e3a8-4f95-98aa-154305a390a3Fri, 24 Feb 2023 00:23:09 +0000https://blog.rust-lang.org/inside-rust/2023/02/23/keyword-generics-progress-report-feb-2023.htmlYoshua Wuyts
We're happy to share that we've made a lot of progress over these last several months, and we're finally ready to start putting some of our designs forward through RFCs. Because it's been a while since our last update, and because we're excited to share what we've been working on, in this post we'll be going over some of the things we're planning to propose.]]>0f940b79-bca2-42b9-a22d-5f0f4079356aFri, 17 Feb 2023 00:32:56 +0000https://www.warp.dev/blog/why-is-building-a-ui-in-rust-so-hardAloke Desai
In this post, I’ll discuss why Rust’s unique memory management model and lack of inheritance makes traditional techniques to build a UI framework difficult and a few of the ways we’ve been working around it. I believe one of these approaches, or some combination of them, will ultimately lead to a stable cross-platform UI toolkit for high-performance UI rendering that everyone can use.]]>8557684f-9c19-432c-a9dd-297ef49f26b9Wed, 8 Feb 2023 23:19:18 +0000https://mainmatter.com/blog/2023/02/01/using-rust-crates-in-elixir/Bartlomiej Dudzik4f6bd9d4-aa60-4c84-a5cf-4559f18432ffMon, 6 Feb 2023 22:10:31 +0000https://bundler.io/blog/2023/01/31/rust-gem-skeleton.htmlJosef Šimánek
Officially it all started when YJIT was ported to Rust and Ruby codebase has officially onboarded Rust code. This friendship matured when RubyGems 3.3.11 (with a new Add cargo builder for rust extensions feature) was released capable of compiling Rust-based extensions during gem installation process (similar to well-known C-based gem extensions like nokogiri, pg or puma).

And now, with Bundler 2.4, bundle gem skeleton generator can provide all the glue you need to start using Rust inside your gems thanks to the new --ext=rust parameter!]]>5f6a9b4c-0ca3-4124-954d-973ed77953c1Wed, 21 Dec 2022 22:51:56 +0000https://blog.yoshuawuyts.com/rust-2023/Yoshua Wuyts5040f17c-6e1a-4e9f-9d49-df26723e5947Wed, 21 Dec 2022 22:45:25 +0000https://steveklabnik.com/writing/ten-years-of-ru---ewriting-my-websiteSteve Klabnik2106efb4-341b-429d-a321-d68ee87ef026Tue, 22 Nov 2022 23:06:11 +0000https://xeiaso.net/blog/carcinization-golangXe Iaso
I've done this with a package I call mastosan and here's why it exists as well as how I made it.]]>e3507c8b-0d53-4319-8a51-a3e8d1f7fab5Sat, 29 Oct 2022 03:16:23 +0000https://blog.rust-lang.org/2022/10/28/gats-stabilization.htmlJack Huey
The goal of this post is not to teach about GATs, but rather to briefly introduce them to any readers that might not know what they are and to enumerate a few of the limitations in initial stabilization that users are most likely to run into.]]>57c5a854-aa88-4a4e-9ffd-ea5d07b63059Fri, 21 Oct 2022 00:38:58 +0000https://bjorn3.github.io/2022/10/12/progress-report-okt-2022.htmlbjorn31b831865-6b0e-40ad-aaa1-fad74c579eb3Fri, 21 Oct 2022 00:25:01 +0000https://lwn.net/Articles/909887/Jonathan Corbetd00f607a-dd9a-439f-b575-4a3e8fc84bbaFri, 21 Oct 2022 00:21:38 +0000https://www.thecodedmessage.com/posts/raii/Jimmy Hartzell
I will start by talking about the problem that RAII was originally designed to solve. Then, I will re-hash the basics of how RAII works, and work through memory usage patterns where RAII needs to be combined with these other features, especially the borrow checker. Finally, I will discuss the downsides of these memory management techniques, especially performance implications and handling of cyclic data structures.]]>86cf9687-80b8-41d5-bcc6-6a2231cf6167Thu, 6 Oct 2022 23:20:21 +0000https://matklad.github.io//2022/10/06/hard-mode-rust.htmlAleksey Kladova8b1fc93-d40e-4657-bc5c-4be74900d017Tue, 4 Oct 2022 22:41:38 +0000https://neosmart.net/blog/2022/implementing-truly-safe-semaphores-in-rust/Mahmoud Al-Qudsi23d19424-6b61-4b68-baf2-86d2bb0339ceThu, 29 Sep 2022 07:20:47 +0000https://www.ralfj.de/blog/2022/09/26/cargo-careful.htmlRalf Jung4c86f33e-b0cb-4dfa-b6b3-f3c9a1afcb57Thu, 29 Sep 2022 07:12:59 +0000https://blog.yoshuawuyts.com/futures-concurrency-4/Yoshua Wuyts85880050-b10b-4dff-8e8d-9ebe0ba9dac1Tue, 3 Aug 2021 22:32:48 +0000https://blog.guillaume-gomez.fr/articles/2021-08-03+Improvements+for+%23%5Bdoc%5D+attributes+in+RustGuillaume Gomez441fe215-d96a-46f9-9b14-d8454e96bf5cTue, 3 Aug 2021 22:21:59 +0000https://blog.rust-lang.org/2021/08/03/GATs-stabilization-push.htmlJack Hueyf6cc142b-0e71-4f14-961b-04acaed22f18Wed, 21 Jul 2021 22:07:50 +0000https://blog.rust-lang.org/2021/07/21/Rust-2021-public-testing.htmlNiko Matsakis4dbb6701-62e7-4f07-a1fb-e615e7209eddThu, 18 Mar 2021 22:42:10 +0000https://blog.rust-lang.org/2021/03/18/async-vision-doc.htmlNiko Matsakis
We are launching a collaborative effort to build a shared vision document for Async Rust. Our goal is to engage the entire community in a collective act of the imagination: how can we make the end-to-end experience of using Async I/O not only a pragmatic choice, but a joyful one?]]>5f441546-be0e-4188-8da7-ca50dd09a055Thu, 25 Feb 2021 00:43:54 +0000https://ferrous-systems.com/blog/ferrocene-update-three-the-road/Ferrous Systemsa0ccf1a1-71f4-4af0-b747-4edfaf9e8852Thu, 28 Jan 2021 03:46:29 +0000https://blog.rust-lang.org/inside-rust/2021/01/26/ffi-unwind-longjmp.htmlKyle Strand on behalf of the FFI-unwind project group2869a0d6-d630-4596-b50d-48553d2812e0Thu, 21 Jan 2021 07:07:23 +0000https://serokell.io/blog/rust-in-production-1passwordGints Dreimanis
For the first installment of the series, we interview Michael Fey, VP of Engineering at 1Password. Read further to find out why they chose Rust for their product, the benefits of Rust for security-centered applications, and what cool libraries you should look into if you’re developing something similar in Rust.]]>320973eb-c4e7-419a-8443-384639d658d6Fri, 1 Jan 2021 22:33:12 +0000https://blog.rust-lang.org/2020/12/31/Rust-1.49.0.htmlThe Rust Release Team44604af1-3b26-4526-8469-3fc3b32dade0Mon, 14 Dec 2020 22:26:49 +0000https://blog.rust-lang.org/2020/12/11/lock-poisoning-survey.htmlAshley MannixOne of those API changes we're looking at is non-poisoning implementations of Mutex and RwLock.

To find the best path forward we're conducting a survey to get a clearer picture of how the standard locks are used out in the wild.]]>3b12df03-9627-4c4c-8c91-d56079e52f5aFri, 27 Nov 2020 22:10:09 +0000https://blog.rust-lang.org/2020/11/27/Rustup-1.23.0.htmlThe Rustup Working Group
Starting from this release of rustup (1.23.0) you can also install a minor version without specifying the patch version, like 1.48 or 1.45.]]>127e2f60-d549-450e-bd04-c711aea4ecf3Tue, 24 Nov 2020 06:24:26 +0000https://blog.rust-lang.org/inside-rust/2020/11/23/What-the-error-handling-project-group-is-working-on.htmlSean Chen
But there’s still room for improvement. The main focus of the group is carrying on error handling-related work that was in progress before the group's formation. To that end, we're working on systematically addressing error handling-related issues, as well as eliminating blockers that are holding up stalled RFCs.]]>f2dd94db-ddf5-4c16-aa0c-2890b856c586Thu, 19 Nov 2020 20:12:19 +0000https://blog.rust-lang.org/2020/11/19/Rust-1.48.htmlThe Rust Release Teamdocumentation even easier!]]>e0e60133-6e7b-46a5-9836-fe482295f6f5Wed, 21 Oct 2020 22:48:08 +0000https://www.possiblerust.com/pattern/non-generic-inner-functionsAndrew Lilley Brinker71ce0cf6-05fc-4aca-9485-85ed2b8be1bcMon, 12 Oct 2020 09:55:52 +0000http://dtrace.org/blogs/bmc/2020/10/11/rust-after-the-honeymoon/Bryan Cantrill2954ca43-e797-43fb-b590-33933c969fbeThu, 8 Oct 2020 22:14:49 +0000https://blog.rust-lang.org/2020/10/08/Rust-1.47.htmlThe Rust Release Teamf74d7084-d61f-460d-be70-54947c2284c6Wed, 30 Sep 2020 06:24:34 +0000https://blog.rust-lang.org/inside-rust/2020/09/29/Portable-SIMD-PG.htmlJubilee and Lokathord236ea20-477c-4eaa-9549-e8ba5d50ad06Tue, 22 Sep 2020 22:00:16 +0000https://blog.yoshuawuyts.com/async-iteration/Yoshua Wuytsd88da501-4e4e-4b6c-b064-62e69e6b0aa4Mon, 21 Sep 2020 21:40:21 +0000https://blog.rust-lang.org/2020/09/21/Scheduling-2021-Roadmap.htmlThe Rust Core Team07d182e9-6e49-491a-b6ca-6d70bc9ac22aMon, 21 Sep 2020 00:29:34 +0000https://vorner.github.io/2020/09/20/throw-away-code.htmlMichal Vaner86e79ae7-04eb-4bea-afba-4459439c606bFri, 4 Sep 2020 00:48:46 +0000https://blog.rust-lang.org/2020/09/03/Planning-2021-Roadmap.htmlThe Rust Core Teame75b99c2-87b7-42b6-b6b5-15e8c0afdf90Wed, 2 Sep 2020 10:14:06 +0000https://immunant.com/blog/2020/09/transpiled_c_safety/Per Larsen
This post explores how the current output of the C2Rust translator can be further hardened. Most blog posts on porting C code to Rust rely on human intelligence. The goal here is to explore the smallest set of changes we can make to get to safe Rust without a human in the loop. The idea is that the simpler the changes, the greater the odds that we can automate them.]]>931184e7-9939-44ef-94f7-07d77717c227Wed, 2 Sep 2020 10:12:37 +0000https://headcrab.rs/2020/08/31/august-update.htmlHeadcrab
We have extended core functionality, implementing important debugger features such as stack unwinding (which is necessary for displaying backtraces), reading of local variables, and disassembly view.]]>03084c56-40c9-4502-869d-e53e0a6e908aWed, 2 Sep 2020 10:08:03 +0000https://mun-lang.org/blog/2020/08/30/this-month-august/Mun Programming Languageae893076-355b-459c-8403-10007797a55eMon, 31 Aug 2020 10:29:54 +0000https://vegapit.com/article/sudoku-solver-idiomatic-rustVegapit63ef0bf8-68d1-49a3-a6b0-c270240d6a5cThu, 27 Aug 2020 23:16:43 +0000https://blog.rust-lang.org/2020/08/27/Rust-1.46.0.htmlThe Rust Release Teamd3f0e9cb-dc14-4b19-8d69-a5933cc2e7c6Thu, 27 Aug 2020 23:15:52 +0000https://belkadan.com/blog/2020/08/Objective-Rust/Jordan Rose7fc33219-240e-4cf5-8916-3eaac24a1714Thu, 27 Aug 2020 11:16:36 +0000https://jack.wrenn.fyi/blog/include-transmute/Jack
A few years ago, for coursework, I implemented a basic neural network for recognizing digits. Ever-obsessed with having the fastest implementation in the class, I statically included the learned network parameters it was wrong, and I got lucky.

A Matrix has a minimum alignment of 8, but include_bytes! merely produces a reference to a byte array—with no care for alignment.

How can we ensure the included bytes are properly aligned?]]>7623458b-9004-432b-9063-49e80d2dc23bTue, 25 Aug 2020 11:06:16 +0000https://www.fpcomplete.com/blog/different-levels-async-rust/Michael Snoyman
Sitting around and waiting for stuff? Ain't nobody got time for that. Spawning threads at the operating system level? That's too costly for a lot of what we do these days.

Perhaps the first foray into asynchronous programming that really hit the mainstream was the Nginx web server, which boasted a huge increase in throughput by natively using asynchronous I/O system calls. Some programming languages, like Go, Erlang, and Haskell, built runtimes systems that support spawning cheap green threads, and handle the muck of asynchronous system calls for you under the surface. Other languages, such as Javascript and more recently Rust, provide explicit asynchronous support in the language.

Given how everyone seems to be bending over backwards to make it easy for you to make your code async-friendly, it would be fair to assume that all code at all times should be async. And it would also be fair to guess that, if you stick the word async on a function, it's completely asynchronous. Unfortunately, neither of these assumptions are true. This post is intended to dive into this topic, in Rust, using a simple bit of code for motivation.]]>06e93ba1-63e1-431e-a2bd-4a80e1b84891Tue, 25 Aug 2020 11:02:14 +0000http://fitzgeraldnick.com/2020/08/24/writing-a-test-case-generator.htmlNick Fitzgerald

> I’d like to learn about fuzzing, specifically fuzzing programming language
> implementations. Do you have reading materials you would recommend, blog
> posts, papers, books or even recorded talks?

Maxime received many replies linking to informative papers, blog posts, and lectures. John Regehr suggested writing a simple generative fuzzer for the programming language.]]>24195757-b669-448f-8d3a-f653c727e5ddMon, 24 Aug 2020 09:50:03 +0000https://matklad.github.io//2020/08/15/concrete-abstraction.htmlAleksey Kladovd237d4eb-6da5-4019-b61e-0953c1add6b5Mon, 24 Aug 2020 09:48:24 +0000https://ryhl.io/blog/temporary-shared-mutation/Alice Ryhlon the Cell type:

Cell::from_mut This method turns a &mut T into a &Cell.
Cell::as_slice_of_cells This method turns a &Cell<[T]> into a &[Cell].

Both methods were released in version 1.37.0 of Rust, exactly one year ago from the date this post was published.]]>69582d03-1be8-4d2d-b61e-658e10278152Mon, 24 Aug 2020 09:38:21 +0000https://steveklabnik.com/writing/the-cxx-debateSteve Klabnik21b48cc8-fccd-44f8-8f99-ea859792cde8Mon, 24 Aug 2020 09:35:22 +0000https://www.abubalay.com/blog/2020/08/22/safe-bindings-in-rustRussell Johnston
The response to this document has included a lot of confusion and misinformation. Really, this is a continuation of a larger ongoing discussion of how to use unsafe properly. Rust FFI and unsafe are complicated and often subtle topics, so here I am going to attempt to summarize the issues and suggest how we might address them.]]>82fd8aa2-239b-46b8-997d-5af23dc41c68Mon, 24 Aug 2020 09:30:33 +0000https://codecrash.me/understanding-rust-slicesLeon and found that I actually didn’t know whether my code would lead to a memory leak. This lead me down a rabbit hole to understand how exactly slices work in Rust.]]>12421292-4ff1-4857-80d5-31c80bf386d8Mon, 24 Aug 2020 09:28:52 +0000https://people.gnome.org/~federico/blog/rust-stable-abi.htmlFederico Mena Quintero
1. Compiled Rust code doesn't have a stable ABI (application binary interface).
2. So, we can't have shared libraries in the traditional fashion of Linux distributions.
3. Also Rust bundles its entire standard library with every binary it compiles, which makes Rust-built libraries huge.

These are extremely valid concerns to be addressed by people like myself who propose that chunks of infrastructural libraries should be done in Rust.

So, let's begin.]]>b3575d5b-86ac-4e2b-ab1b-bf2d839adbffThu, 20 Aug 2020 10:13:06 +0000https://alexene.dev/2020/08/17/webassembly-without-the-browser-part-1.htmlAlexandru Enef3704ab4-bbe3-4597-807d-0d255043b58cThu, 20 Aug 2020 10:05:47 +0000https://www.chromium.org/Home/chromium-security/memory-safety/rust-and-c-interoperabilityThe Chromium Project
We'd need to solve these before considering Rust as (nearly) a first-class citizen in our codebase. If we can’t solve these, Rust would at best be isolated to “leaf nodes” which don’t interact much with the rest of our codebase. And if that’s all we can use Rust for, that calls into question whether the costs of an extra language are justified in the first place.]]>e3260b57-b747-4857-99a6-a1dd81e044c3Tue, 18 Aug 2020 22:04:15 +0000https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.htmlThe Rust Core Team
Mozilla was, and continues to be, excited by the opportunity for the Rust language to be widely used, and supported, by many companies throughout the industry. Today, many companies, both large and small, are using Rust in more diverse and more significant ways, from Amazon’s Firecracker, to Fastly’s Lucet, to critical services that power Discord, Cloudflare, Figma, 1Password, and many, many more.

On Tuesday, August 11th 2020, Mozilla announced their decision to restructure the company and to lay off around 250 people, including folks who are active members of the Rust project and the Rust community. Understandably, these layoffs have generated a lot of uncertainty and confusion about the impact on the Rust project itself. Our goal in this post is to address those concerns. We’ve also got a big announcement to make, so read on!]]>d4a95988-62b4-4392-89a1-6a40ebbd3f30Tue, 18 Aug 2020 10:38:28 +0000https://jam1.re/blog/why-rusts-unsafe-worksjam1garnerf775c77e-67f0-4410-a2a9-c849301c1178Tue, 18 Aug 2020 10:29:34 +0000https://fasterthanli.me/articles/frustrated-its-not-you-its-rustAmos
What makes it worse is that it doesn't matter how much prior experience you have, in Java, C#, C or C++ or otherwise - it'll still be unnerving.

In fact, more experience probably makes it worse! The habits have settled in deeper, and there's a certain expectation that, by now, you should be able to get that done in a shorter amount of time.

Maybe, after years of successfully shipping code, you don't have quite the same curiosity, the same candor and willingness to feel "lost" that you did back when you started.

Learning Rust makes you feel like a beginner again - why is this so hard? This doesn't feel like it should be that hard. I've done similar things before. I know what I want. Now I just need to... make it happen.

I'm going to keep including introductions like these in all my beginner-level articles, because they're very important: if you're picking up Rust, expect roadblocks.]]>87d0a317-5d3d-41be-8853-ea1e6031e1aaThu, 13 Aug 2020 09:54:15 +0000https://www.christianfscott.com/rust-chars-vs-go-runes/Christian Scott
The answer is that a char is a Unicode Scalar Value, whereas a rune is a Unicode Code Point. That is… not very helpful. What’s the difference between those things?

A crappy but correct answer to this question is “a unicode scalar value is any unicode code point except high surrogate and low surrogate code points”. Ugh. You need a fair bit of context to understand this, so I will do my best to explain it from the beginning.]]>904e6ae4-68cf-4113-87c8-dbc340dfccfeThu, 13 Aug 2020 09:47:14 +0000https://gendignoux.com/blog/2020/06/16/rust-5-years-full-stack.htmlGuillaume Endignoux
Whether Rust is a full-stack programming language is still a hot debate, my opinion is that it is, and I hope that this blog post will convince you as well!

After that, I’ll conclude this series of posts with some perspectives on the Rust ecosystem, and Rust’s upcoming role in the job market.]]>3bcd7f77-2bb8-4e73-b578-785a4a1c33b3Thu, 13 Aug 2020 09:45:54 +0000https://matklad.github.io//2020/08/12/who-builds-the-builder.htmlAleksey Kladov5fd8fef3-b672-429a-9ce0-7d073f24ef46Wed, 12 Aug 2020 09:35:40 +0000https://blog.logrocket.com/property-based-testing-in-rust-with-proptest/Zach Mitchell
Today you’ll learn about property-based testing (PBT), including how it works, when it makes sense, and how to do it in Rust.]]>74e96b4b-6a79-4a17-a20b-df2726867e23Wed, 12 Aug 2020 09:34:38 +0000https://gendignoux.com/blog/2020/06/16/rust-5-years-cross-platform.htmlGuillaume Endignoux
Therefore, to celebrate these five years, I’ve decided to write a series of blog posts explaining why I think Rust is a language of choice, and where to find relevant resources to use Rust across platforms and along the software stack. In this first post of the series, after a brief summary of what is Rust and why it’s relevant, I’ll go through the various platforms where Rust can already be used. And Rust already supports so many platforms that I’m sure I’ll forget some!]]>2892657e-0a2a-4cf5-ad98-fab62d8bb715Wed, 12 Aug 2020 09:27:02 +0000https://code.camdenreslink.com/dev/implementing-the-dot-net-profiling-api-in-rust/Camden8109beb6-1e4b-495a-9060-f71ea72f03eeWed, 12 Aug 2020 09:25:35 +0000https://blog.datalust.co/a-tour-of-seqs-storage-engine/Ashley Mannix
Seq is a log server with its own embedded storage engine for log events written (mostly) in Rust. We call this storage engine Flare. We’ve written a bit about our experiences with Rust in the past, but we’ve been wanting to dive into the design of Flare itself since we first shipped it in August of 2018.

To get a sense of what Flare is all about we’ll first introduce its broad design and then explore some of its components. We’ll do this by tracing the ingestion of an event through Seq’s HTTP API through to disk, and then later back from disk via a query, and finally deleting the event entirely. This post is a long and tangential tour of the design and implementation of the database to provide context for deeper dives into specific components in future posts.]]>8531ae0c-a4c5-48ec-abf7-e9e362c6c24dTue, 11 Aug 2020 10:57:45 +0000https://willcrichton.net/notes/type-safe-printf/Will Crichtonc89b304b-4c2f-43e3-8cf6-cce4d681bea4Tue, 11 Aug 2020 10:55:50 +0000https://www.possiblerust.com/pattern/rust-lints-you-may-not-knowAndrew Lilley Brinker595082c1-445c-4392-a242-6d104ae8d514Tue, 11 Aug 2020 10:48:38 +0000https://freyskeyd.fr/posts/building-chekov-part-1-design-the-eventstore/Simon Paitrault
In this blog series I will cover my way of building an OpenSource framework called Chekov. I will try to describe how I design and implement the whole thing. I will start from scratch, I will fail sometimes, but I will learn a lot and you too. I will try to cover as much part of the reflexion I have, feel free to ask for more details on Twitter or at the end of each blog post.]]>78320bf3-9a53-4ea7-a0d9-7c10034373ceTue, 11 Aug 2020 10:39:22 +0000https://robert.ocallahan.org/2020/08/scaling-debuginfo-for-zero-cost.htmlRobert O'Callahanb73a7049-39a2-47c8-aa3e-a9bc97fd5756Mon, 10 Aug 2020 10:38:30 +0000https://sharpend.io/7-things-i-learned-from-porting-a-c-crypto-library-to-rust/Mathias Lafeldt
Given these benefits, it’s no surprise that I keep coming back to Rust. This time, I decided to revisit a pull request from five years ago, which has been lingering in my mind ever since. The ambiguous goal of the pull request is to port cb2util, one of my old crypto tools for PlayStation 2, from C to pure Rust.]]>352f34cd-f354-4504-ae3c-1112504eaaf0Mon, 10 Aug 2020 10:29:11 +0000https://fasterthanli.me/articles/surviving-rust-async-interfacesAmos
But thanks to the work done by the whole community, async Rust is getting easier to use every week. One project I think is doing particularly great work in this area is async-std.]]>0cddc991-71f1-472b-80ef-844fb73d6a40Mon, 10 Aug 2020 10:22:28 +0000https://github.com/paulkernfeld/contiguous-data-in-rustPaul Kernfeld
Contiguous data is when multiple pieces of data are stored next to each other in memory. It is often a great way to store collections, because it can provide great cache locality and branch prediction.]]>cbedfe4d-5a19-479a-99e1-560047882aa6Sat, 8 Aug 2020 10:25:39 +0000https://www.philipdaniels.com/blog/2020/self-cloning-for-multiple-threads-in-rust/Philip Daniels
I would like to share it with you. I’d say this is an intermediate-level article, since the Rust compiler won’t lead you towards this design, good as its error messages are.]]>3218a357-048d-421b-b4c0-6a4693cd9d6aSat, 8 Aug 2020 10:23:29 +0000https://blog.x5ff.xyz/blog/async-tests-tokio-rust/Claus
… or are there? Rust has recently started supporting full async/await abilities after years of development and it looks like there is a missing piece there: tests. How so?]]>2663e6dd-7afd-42a2-a1bf-f3eea61f9884Sat, 8 Aug 2020 10:16:34 +0000https://www.possiblerust.com/guide/inbound-outbound-ffiAndrew Lilley Brinkeraebfc319-de3c-4a45-9cf7-9b02ca561d20Sat, 8 Aug 2020 10:10:47 +0000https://killavus.github.io/posts/thread-pool-graceful-shutdown/Marcin Grzywaczewski27112569-1a6a-4ea1-bb2a-45f7dadf5de6Sat, 8 Aug 2020 10:07:02 +0000https://notes.iveselov.info/programming/allocation-api-and-allocatorsIvan Veselov
In Rust, standard library documentation is extremely readable and even has a section "How to read this documentation" for people like me. Let me quote from it: "If this is your first time, the documentation for the standard library is written to be casually perused. Clicking on interesting things should generally lead you to interesting places."

So, I started reading and here we go. The very first module in the documentation is: alloc.]]>73558f62-b55e-4b75-a47c-999ed72740deFri, 7 Aug 2020 00:47:47 +0000https://john-millikin.com/first-impressions-of-rustJohn Millikin I took some notes along the way about things that struck me as especially good or bad. Overall I quite like Rust the language, have mixed feelings about the quality of ancillary tooling, and have strong objections to some decisions made by the packaging system (Cargo + crates.io).]]>538f2223-3f96-4ff7-a7cf-c67760da52fdThu, 6 Aug 2020 10:19:35 +0000https://esimmler.com/building-canrun-part-1/Erik Simmler
In my initial post I mentioned going through a few fundamental revisions before settling on the current approach. Here I'll try to do a quick recap for two reasons: 1) I think it's neat, and 2) with luck I'll snag the attention of someone with deeper experience and a willingness to share some tips.

My first successful attempt was actually based on an article by Tom Stuart titled "Hello, declarative world", which described a way to implement μKanren in Ruby. I recommend reading that if you find yourself confused about any of the "why" I gloss over here.]]>4c05c438-5778-45bd-82f3-4259a34a533eThu, 6 Aug 2020 10:14:03 +0000https://dev.to/gnunicorn/hunting-down-a-non-determinism-bug-in-our-rust-wasm-build-4fk1Benjamin Kampmann377afeba-3051-44eb-8e7a-1d907856f968Thu, 6 Aug 2020 10:12:49 +0000https://www.reddit.com/r/rust/comments/hzkgep/i_rewrote_the_c_donut_in_rust/Dan Conleh6fa1befb-5f61-464d-8887-95f8ae322cf4Wed, 5 Aug 2020 10:14:57 +0000https://pnevyk.github.io/posts/query-system-in-rust/Petr Nevyhoštěnýff2ff756-d63b-419d-86af-168e3c132017Wed, 5 Aug 2020 10:12:31 +0000https://deislabs.io/posts/a-heaping-helping-of-stacks/Taylor Thomas57db6da3-5230-4b7f-ab09-1bc6b251f9a1Wed, 5 Aug 2020 10:11:28 +0000https://blog.darrien.dev/posts/my-rust-experiences/Darrien
What I didn’t mention (although is fairly obvious if you look at the code) is that Typeracer was my first real exposure to Rust.

I went through a bit of the rust book and wrote a tiny compression tool that did a sort of run length encoding algorithm, but both of them were super simple and I really wanted something I could work on for longer to understand the language.

Working on the two I almost never interacted with the borrow checker. I had no idea what I was getting myself into. But there had to be a reason for uh, super vocal subreddits about rust, so I figured it was time to see what all the hype was about.]]>0f8978d6-db73-4c25-aeb7-c13aa10d23b3Wed, 5 Aug 2020 10:06:19 +0000https://blog.logrocket.com/using-the-rust-compiler-as-your-integration-testing-framework/Thomas Eizinger
In this guide, I’ll share some of the knowledge I’ve built up on this topic and present some techniques to make integration testing almost redundant. Ultimately, the question is: Could “It compiles, let’s ship it!” actually be true for Rust?]]>cb8a62a3-3fe8-4d96-91d5-2d9f47949d6aWed, 5 Aug 2020 10:02:34 +0000http://benkonz.github.io//building-a-brainfuck-compiler-with-rust-and-llvm/Ben Konz
This tutorial is going to go over how to create a simple compiler using LLVM for Brainf*ck in Rust. The completed code can be found here: brainfrick-rust]]>ad2699b9-b23f-464f-9152-385848a11518Wed, 5 Aug 2020 09:59:02 +0000https://lfn3.net/2020/08/03/a-gentle-intro-to-assembly-with-rust/Liam
And compared to some other ways I’ve tried to approach this there’s a lot less setup we need to do if we just use the rust playground to do all the heavy lifting.

My process for figuring things out has been pretty simple. I write a tiny bit of rust code, look at the assembly output and try to figure out what’s going on (with lots of googling). I’m going to walk you through what I did, and what I figured out.]]>7c2867a5-f2e0-4d27-ab5c-7428fcd32a33Wed, 5 Aug 2020 09:56:55 +0000https://blog.ael.red/2020/08/02/evolutionary-algorithms.htmlFelix Chapman
I’ll use Rust for my examples, but follow along in any language you like! It’s said that if you put a monkey in front of a typewriter, given enough time it will produce the complete works of Shakespeare. We haven’t infinite time (or easy access to monkeys!), so let’s try something simpler, reproducing just this fragment from Hamlet:

const HAMLET: &str = "To be, or not to be--that is the question"; ]]>0e43f8e7-16d0-4226-a3b0-58e84d1aa253Tue, 4 Aug 2020 09:49:58 +0000https://cuchi.me/posts/go-vs-rustPaulo Henrique Cuchia3268b22-019c-4e83-b00a-8048c05a3c63Mon, 3 Aug 2020 22:31:59 +0000https://blog.rust-lang.org/2020/08/03/Rust-1.45.2.htmlThe Rust Release Teambfe8b996-2fbf-4e2c-942a-547e59f2959cMon, 3 Aug 2020 09:40:36 +0000https://tiemoko.com/blog/blue-team-rust/Tiemoko Ballo
Like many in the security community, I've been drawn to Rust by the glittering promise of a safe alternative. But what does "safe" actually mean on a technical level? Is the draw one of moths to flame, or does Rust fundamentally change the game?

This post is my attempt to answer these questions, based on what I've learned so far. Memory safety is a topic knee-deep in operating system and computer architecture concepts, so I have to assume formidable prior systems security knowledge to keep this post short-ish. Whether you're already using Rust or are just flirting with the idea, hope you find it useful!]]>d7a475b2-3491-4ebe-b3a0-2014bc0968a1Mon, 3 Aug 2020 09:38:06 +0000https://blog.rust-lang.org/2020/07/30/Rust-1.45.1.htmlThe Rust Release Teame2adc251-bd52-48f4-85e8-5442e6204ec8Wed, 29 Jul 2020 10:03:19 +0000https://seanchen1991.github.io/posts/rust-representer/Sean Chen
One of the most challenging hurdles the Exercism platform faces is the fact that students who opt in to receive mentor feedback on their work have to wait for a live person to get around to reviewing their submission. Decreasing wait times for students is thus an important metric to optimize for in order to improve the overall student experience on the platform.

In this post I’ll be talking about a project I’ve been working on that aims to address this problem. I’ll also be discussing the learnings I’ve been taking away from working on this project, as it’s my first non-toy Rust project that I’ve undertaken.]]>d14cd33b-6af1-42e5-b3c1-8c8262208a12Wed, 29 Jul 2020 09:37:25 +0000https://sebnilsson.com/blog/from-csharp-to-rust-introduction/Seb Nilsson1736a344-41dd-497b-8414-3bc814c53975Tue, 28 Jul 2020 23:27:05 +0000https://blog.rust-lang.org/inside-rust/2020/07/27/opening-up-the-core-team-agenda.htmlPietro Albini60d63315-594d-42a2-a667-532813faaae3Tue, 28 Jul 2020 23:26:18 +0000https://blog.rust-lang.org/inside-rust/2020/07/27/1.45.1-prerelease.htmlMark RousskovThursday, the 30th.]]>ecadb645-ef6c-42cb-858f-f9688e79a1beMon, 27 Jul 2020 09:42:43 +0000https://www.fpcomplete.com/insights/rust-at-fpco-2020/Michael Snoyman
For the entire history of our company, our contention has been that while some level of trade-off here is inevitable, we can leverage better tools, languages, and methodologies to improve our standing on all of these pillars. We initially focused on Haskell, a functional programming language that uses a strong type system and offers decent performance. We still love and continue to use Haskell. However, realizing that code was only half the battle, we then began adopting DevOps methodologies and tools.

In this post, I wanted to share some thoughts on why we're thrilled to see Rust's adoption in industry, what we're using Rust for at FP Complete, and give some advice to interested companies in how they can begin adopting this language.]]>4ff07e4a-b171-48d3-a455-a5f3a05c5135Mon, 27 Jul 2020 09:37:25 +0000https://nbsoftsolutions.com/blog/my-bet-on-rust-has-been-vindicated.htmlNick Babcock
I’m writing this post as whenever Rust is posted on the internet, it tends to elicit polar opposite responses: the evangelists and the disillusioned. Both can be correct in their viewpoints, but when one is neck deep in a Rust side project and stumbles across a discussion that is particularly critical of Rust, self doubt may creep into thoughts. And while self doubt isn’t inherently bad (second guessing can be beneficial), too much doubt can cause one to disengage with their hobby. This post is me sharing struggles seen along the way and realizing that the wins Rust gave me far outweigh the struggles.]]>a2e4cdc4-06ad-4e3c-8638-7b8f4a6622b4Sat, 25 Jul 2020 10:15:36 +0000https://rust.graystorm.com/2020/07/20/a-few-advanced-variable-types-in-rust/Jeff Culverhouse40f8b560-5dcf-4ac5-8b06-8c32daba2f4aSat, 25 Jul 2020 10:11:39 +0000https://notes.iveselov.info/programming/checking-status-of-rust-featuresIvan Veselov9dfd8d9a-b93f-4514-bbac-ab818bbaf3efSat, 25 Jul 2020 10:04:10 +0000https://m-decoster.github.io/Mathieu De Coster