Change:
There are a number of small typos in the guide, and some of the prose could be tightened up or clarified. In general the tone of the guide comes across as trying too hard to be chatty. Keeping things casual is probably a good idea for Rust's introductory document, but we can probably remove most (all?) of the chatty prose without becoming stodgy or boring.
The guide is inconsistent with its use of certain conventions. These don't really have a correct form, but a single style should be enforced. Single-quotes () versus double-quotes () in prose. Example: Periods and commas within quotes versus without. Example: "different from" versus "different than". Example: "filename" versus "file name"
If you find any obvious errors, or think you can write a section in a better way, please don't hesitate to submit a PR with a fix. You don't need to compile a compiler or download the source to edit the guide. You can do it all in github's ui, for the most part.
thanks for being specific. And for your earlier pull request. As for these... They should be double quotes. Ideally, they'd even be actual curlies rather than . Periods and commas go within in almost all cases. In both of the cases you show, they should go inside. "Different from" vs. "Different than" isn't something that's generally settled. Some styles choose it in different situations, others say "from" is the only correct way to say this. "file name" is my preferred way, though there's no specific actual guidance.

Discussion:
``` Rust files always end in a `.rs` extension. If you're using more than one word <del> in your file name, use an underscore. `hello_world.rs` rather than </del> <ins> in your filename, use an underscore. `hello_world.rs` rather than </ins> `helloworld.rs`. Now that you've got your file open, type this in:

means that you're calling a macro instead of a normal function. Rust implements `println!` as a macro rather than a function for good reasons, but that's a very advanced topic. You'll learn more when we talk about macros later. One <del> last thing to mention: Rust's macros are significantly different than C macros, </del> <ins> last thing to mention: Rust's macros are significantly different from C macros, </ins> if you've used those. Don't be scared of using macros. We'll get to the details eventually, you'll just have to trust us for now.

``` This reveals two interesting things about Rust: it is an expression-based <del> language, and semicolons are different than in other 'curly brace and semicolon'-based languages. These two things are related. </del> <ins> language, and semicolons are different from semicolons in other 'curly brace and semicolon'-based languages. These two things are related. </ins> ## Expressions vs. Statements

# Strings Strings are an important concept for any programmer to master. Rust's string <del> handling system is a bit different than in other languages, due to its systems </del> <ins> handling system is a bit different from other languages, due to its systems </ins> focus. Any time you have a data structure of variable size, things can get tricky, and strings are a re-sizable data structure. That said, Rust's strings also work differently than in some other systems languages, such as C.