This looks like a great resource, but seems targeted at folks who’ve already dipped their toes in to the water. For first-timers, the maintainers of Rustlings suggest the official book and Rust By Example.

You’re still gonna want Nmap, but RustScan drastically speeds up the first step (scans all 65k ports in less than a minute) and then pipes its data to Nmap.

dijo is a habit tracker. It is curses-based, it runs in your terminal. dijo is scriptable, hook it up with external programs to track events without moving a finger. dijo is modal, much like a certain text editor.

pgx is a framework for developing PostgreSQL extensions in Rust and wants to make that process as idiomatic and safe as possible. Currently, pgx supports Postgres v10, v11, and v12.

If this interests you, check out the examples directory that shows you how to work with arrays, errors, strings, and more.

While I like the acronym so, this tool would actually be better described as se: an interface to the StackExchange network. In particular one thing that differentiates it from similar tools is that you can simultaneously search any number of sites in the StackExchange network

This is part 3 of a three part series from Sheshbabu Chinnakonda introducing the Rust language to JavaScript developers — this one is focused on functions and control flow.

When Shesh kicked off this series he said, “I find it easier to understand something new if it was explained in terms of something I already know. I thought there might be others like me.”

BTW, here are links to the others from this series:

• Tooling Ecosystem Overview
• Variables and Data Types

No matter how much investment software companies may put into tooling and training their developers, “C++, at its core, is not a safe language,” said Ryan Levick, Microsoft cloud developer advocate, during the AllThingsOpen virtual conference last month, explaining, in a virtual talk, why Microsoft is gradually switching to Rust to build its infrastructure software, away from C/C++. And it is encouraging other software industry giants to consider the same.

This sounds SO familiar, as heard from Josh Aas recently on The Changelog (listen here).

We certainly should not be writing any new code in C and C++. The opportunity for vulnerabilities – I mean, it absolutely will have vulnerabilities, and we need to get that type of code away from our networks to start with, and then probably away from most other things, too… So I would hope that in 10-20 years we think it’s crazy to be deploying major (or maybe even minor) pieces of software that are written in languages that are not memory-safe.

So we’re trying to remove code written in C and C++ from our infrastructure at Let’s Encrypt. I think that’s just a basic part of diligence applied to secure infrastructure. If your stack is some giant pile of C++ or C at the network edge, followed by OpenSSL written in C, followed by a Linux kernel written in C, glibc - your whole pathway has got all this code that you just know is full of security holes. It absolutely is. You just can’t claim that those are even close to secure systems. They’re absolutely not. We’re gonna look back on this and say “That was crazy. We have better options today.”

A Rust/WASM port of the Python code from the article “Writing a full-text search engine using Bloom filters”. This can be seen as an alternative to lunr.js and elasticlunr.

The idea is to generate a small, self-contained WASM module from a list of articles on your website and ship it to browsers. tinysearch can be integrated into the build process of generators like Jekyll, Hugo, zola, or Cobalt.

Kick the tires on the author’s blog.

This tool is a rewrite of ngxtop to make it more easily installed and hopefully quicker. For those unfamiliar with the ngxtop, it is a tool that helps you parse NGINX access logs and print various statistics from them regardless of format. It is currently not feature complete with the original version but it should have enough functionality to be usable.

If you already have Rust installed you can cargo install topngx and you’re off to the races.

topngx < /path/to/access.log

# Output:
count  avg_bytes_sent  2XX  3XX  4XX  5XX
2      346.5           2    0    0    0
request_path              count  avg_bytes_sent  2XX  3XX  4XX  5XX
GET / HTTP/1.1            1      612             1    0    0    0
GET /some_file1 HTTP/1.1  1      81              1    0    0    0

With the combined goal of gaining a deep understanding of DNS, of doing something interesting with Rust, and of scratching some of my own itches, I originally set out to implement my own DNS server. This document is not a truthful chronicle of that journey, but rather an idealized version of it, without all the detours I ended up taking. We’ll gradually implement a full DNS server, starting from first principles.

5 Chapters short.

This year marks five years of Rust. On the Rust blog they reflect back on all the major changes since 1.0.

Rust has changed a lot these past five years, so we wanted to reflect back on all of our contributors’ work since the stabilization of the language.

When Rust turned 1.0 you could count the number of companies that were using it in production on one hand. Today, it is being used by hundreds of tech companies with some of the largest tech companies such as Apple, Amazon, Dropbox, Facebook, Google, and Microsoft choosing to use Rust for its performance, reliability, and productivity in their projects.

Is this more proof of Cunningham’s law, which says, “The best way to get the right answer on the Internet is not to ask a question; it’s to post the wrong answer.”

Update: as some keen HN commenters have pointed out, it looks like the rust program is not actually equivalent to the go program. The go program parses the string once, while the rust program parses it repeatedly inside every loop. It’s quite late in Sydney as I write this so I’m not up for a fix right now, but this post is probably Fake News.

Read Christian’s post then have fun in the comments and discussions on HN and Reddit analyzing his hypothesis, which includes a repo of code to backup his ideas.

This is a port of robmikh’s Minesweeper using Microsoft’s Rust for Windows runtime. If you like Minesweeper, and/or Rust, and/or Windows… this repo’s for you.

Delta provides language syntax-highlighting, within-line insertion/deletion detection, and restructured diff output for git on the command line. All the syntax-highlighting color themes that are available with bat are available with delta. Here’s what git show looks like when git is configured to use delta as its pager:

MeiliSearch is a powerful, fast, open-source, easy to use and deploy search engine. Both searching and indexing are highly customizable. Features such as typo-tolerance, filters, and synonyms are provided out-of-the-box. For more information about features go to our documentation.

Follow along with Christine Dodrill as she makes a small HTTP service using Rust and Rocket. This can also serve as a new Rust project primer too.

This is how I start a new Rust project. I put all of the code described in this post in this GitHub repo in case it helps. Have fun and be well.

zoxide keeps track of your most frequently used directories and uses a ranking algorithm to navigate to the best match. It was inspired by z and z.lua, but it’s written in Rust and out-performs both:

On my system, compiled with the x86_64-unknown-linux-musl target, hyperfine reports that zoxide runs 10-20x faster than z.lua, which, in turn, runs 3x faster than z. This is pretty significant, since this command runs once at every shell prompt, and any slowdown there will result in an increased loading time for every prompt.

In order to increase fluency in a programming language, one has to read a lot of it. But how can you read a lot of it if you don’t know what it means?

This 28 minute read will walk you through lots of Rust snippets and explain the meaning of the keywords and symbols they contain. Additional learning resources are included at the end too.

Special thanks to the 46 patrons mentioned by name at the end of the post who enable Amos to write and share this type of content.

The TLDR of their reasoning is Go’s garbage collection was causing performance problems at scale. Since Rust doesn’t have a garbage collector, it allowed the team to manage their memory use more effectively. Their results were… uplifting:

Remarkably, we had only put very basic thought into optimization as the Rust version was written. Even with just basic optimization, Rust was able to outperform the hyper hand-tuned Go version. This is a huge testament to how easy it is to write efficient programs with Rust compared to the deep dive we had to do with Go.

This is not a Go sucks switch to Rust story. It is a well-reasoned argument for using one technology over the other when it makes sense to do so.

When starting a new project or software component, we consider using Rust. Of course, we only use it where it makes sense.

The Rust programming language is an ambitious project of the Mozilla Foundation – a language that claims to be the next step in evolution of C and C++. Over the years of existence of these languages some of their basic flaws still haven’t been fixed, like segmentation errors, manual memory control, risks of memory leaks and unpredictable compiler behavior. Rust was created to solve these problems while improving security and performance along the way.

We teamed up with some friends of ours at Heroku to promote the Code-ish podcast so we’re sharing a full-length episode right here in The Changelog’s feed. This episode features Chris Castle with special guests Carol Nichols and Jake Goulding talking about the strengths of the Rust programming language.

Learn more and subscribe at heroku.com/podcasts/codeish.

This is a full-featured replacement for many of your shell’s built-ins.

This is an NES emulator and a work in progress. The CPU, PPU, and APU mostly work, though there are still at least a couple bugs. I’ve mostly tested on Donkey Kong and Super Mario Bros. so far. There are plenty of full-featured emulators out there; this is primarily an educational project but I do want it to run well.

If you’re interested in learning about Rust and/or emulators, this is for you.

SQLx is a modern SQL client built from the ground up for Rust, in Rust.

• Truly Asynchronous. Built from the ground-up using async-std using async streams for maximum concurrency.

• Type-safe SQL (if you want it) without DSLs. Use the query!() macro to check your SQL and bind parameters at compile time. (You can still use dynamic SQL queries if you like.)

• Pure Rust. The Postgres and MySQL/MariaDB drivers are written in pure Rust using zero unsafe code.

bandwhich sniffs a given network interface and records IP packet size, cross referencing it with the /proc filesystem on linux or lsof on MacOS. It is responsive to the terminal window size, displaying less info if there is no room for it. It will also attempt to resolve ips to their host name in the background using reverse DNS on a best effort basis.

This looks much better than me fumbling through lsof’s man page for ten minutes and then giving up.