About

About the Site

Possible Rust is a blog about the Rust programming language.

Specifically, it’s a blog for intermediate Rust programmers; people who’ve maybe finished the official Rust book, and are looking to better understand how to use Rust in the real world, what the patterns are that they might encounter or what to use, or how to read other people’s Rust code.

If that’s not you, that’s alright! I highly recommend starting with some of the official recommended learning materials, including the Rust book, the Rustlings exercise set, or anything else linked from the official website. A lot of work goes into making those materials clear, useful, and organized in a logical progression to effectively teach the language.

I also recommend, at any stage of Rust knowledge, that you read the error messages the compiler gives you. The Rust compiler is very good, and usually gives clear, useful error messages that help guide you from broken code to code that not only compiles, but works correctly.

If you’re at the point where Possible Rust can help, it’s useful to understand a bit of how it’s structured. The site’s posts are organized into five categories:

• Guides: These are walk-throughs of some concepts in Rust’s semantics or its common usage, intended to help build understanding of how Rust works, and how to write Rust successfully.
• Patterns: These are descriptions of real-world programming patterns you may see in Rust code, as well as tips for improving your Rust programming.
• Unpacking (Coming Soon): This category will feature deep dives into popular Rust crates, to identify useful tricks and patterns in them that can be applied to your own code, and to understand how other Rust programmers approach the language and use its guarantees and affordances to produce highly-quality tools and libraries.
• Community: These are discussions of the Rust community, including useful external resources, topics currently under discussion, or opinions on how Rust may evolve in the future.
• Meta: These are posts about the site itself.

Additionally, posts are tagged according to the major language features or concepts they address. You can view them all on the tags page.

The full list of past posts can be found on the archive page. This is likely easier to navigate than scrolling through pages of past posts.

Finally, while the site doesn’t incorporate searching directly, you can limit search results in your preferred search engine to include only the Possible Rust site. My preferred method is with DuckDuckGo.

Outside of the site, all posts are shared to the site’s Twitter account, which may also periodically feature other posts including Rust Q&A sessions, or links to other interesting or useful Rust material. These posts will always be tagged so you can filter them out if you’re uninterested in seeing them.

You can also subscribe to Possible Rust via an Atom/RSS feed. Due to limitations in exposing the full formatting and extra features (including asides, tables, and figure blocks), the feed does not include full post contents. However, the site itself is designed to load extremely quickly, and includes no analytics tracking beyond what’s performed by GitHub Pages (IP address and what page is requested, at minimum). In fact, Possible Rust currently includes no JavaScript at all, and receives a perfect 100 out of 100 score for both mobile and desktop from Google PageSpeed Insights.

The site is also intended to be fully accessible for all users. This includes periodic testing for color contrast and keyboard navigation. I am always looking to do better, and if you encounter a usability challenge, please let me know via a Direct Message to the Possible Rust Twitter account, or by sending an email to possiblerust at gmail.

About Andrew

My name is Andrew Lilley Brinker (“Lilley Brinker” is my last name), and I’ve been writing Rust since 2013. My main focus in the Rust community is on teaching and mentoring. I’ve contributed to a few pieces of official Rust documentation, including the now-defunct Frequently Asked Questions page and a small portion of the Rustomicon. Elsewhere, I’ve taught formal and informal Rust training at MITRE (where I work), provided mentoring to new Rustaceans, taught Rust to undergraduates learning programming language theory, and now I write this blog!

Outside of teaching Rust, I work in software security, building safer and more secure programming languages, working with static and dynamic code analysis, exploring formal methods for proving things about software, and investigating software supply chain risk management. I’m also a manager, and love to mentor and support those I work with, especially newer professionals, in achieving their career aspirations.

You can find my two prior Rust talks on YouTube:

• “Hello and Welcome: Documentation in the Rust Ecosystem” from Rust Belt Rust 2016. This talk describes a way of thinking about documentation in four parts. I still believe this is a useful conceptual model for creating documentation, and that Rust makes producing good documentation, particularly good reference material, easier than many other languages do! The four parts in question are:
  1. The Meet Cute: This is the documentation that first introduces you to something, and convinces you it’s worth exploring further.
  2. The Black Triangle: This is the minimal example of a project showing it doing something cool or worthwhile, and shows how that thing is done, to illustrate its value clearly.
  3. The Walkthrough: This is the guided tour through a project, showing its core concepts and components.
  4. The Reference: This is the complete documentation of all parts of the project.
• “A Tale of Teaching Rust” from RustConf 2017. This is a talk about how I included Rust in an undergraduate programming language theory course, including why I included Rust in the course, what I set out to teach using Rust, and how successful the effort was. More than anything, this talk was intended to push back against the notion that Rust can’t be taught effectively and quickly, by showing that in a manner of a few weeks of a single university course, students with minimal programming knowledge were able to understand and write basic Rust code, and understood Rust’s particular value proposition, and how it differed or was similar to other languages covered in the course.