rust-lang · nikomatsakis · Oct 9, 2019 · Oct 7, 2019
diff --git a/posts/2016-06-30-State-of-Rust-Survey-2016.md b/posts/2016-06-30-State-of-Rust-Survey-2016.md
@@ -14,13 +14,13 @@ We plan to run a similar survey each year to track how we're progressing and spo
 
 We wanted to make sure the survey was open to both users of Rust and to people who didn't use Rust.  Rust users give us a sense of how the current language and tools are working and where we need to improve.  Rust non-users shed light on missing use-cases and obstacles for Rust’s adoption.
 
-![Do you use Rust][do-you-use-rust]{:class="center"}
+![Do you use Rust][do-you-use-rust]
 
 We're happy to report that more than a third of the responses were from people not using Rust.  These respondents gave a lot of great feedback on adoption roadblocks, which we'll talk about later in this blog post.
 
 ## Growing numbers trying Rust
 
-![Time using Rust][time-using-rust]{:class="center"}
+![Time using Rust][time-using-rust]
 
 Almost 2,000 people responded saying they were Rust users.  Of these, almost 24% were new users.  This is encouraging to see.  The community is growing, with a healthy portion of newcomers playing with Rust now that could become long-term users.
 
@@ -30,47 +30,47 @@ Equally encouraging is seeing that once someone has become a Rust user, they ten
 
 We asked a number of questions trying to get a clear picture of what it's like to use Rust today.  The first questions focused on the Rust compiler.
 
-![Versions of Rust you use][versions-of-rust]{:class="center"}
+![Versions of Rust you use][versions-of-rust]
 
 In the above chart, you see the top five rustc version combinations for users writing Rust.  At the time of the survey, version 1.8 was the latest stable release.  This factors strongly in the results as the most popular version of Rust to use.  Perhaps surprisingly is how much the nightly also plays a key role in for many developers, with over 400 using it as their only Rust compiler version. Stabilizing features and APIs, and thereby encouraging transition to the stable channel, continues to be a priority for the team.
 
-![Has an upgrade broken code][after_1_0_broke_code]{:class="center"}
+![Has an upgrade broken code][after_1_0_broke_code]
 
 In the pre-1.0 days, Rust releases would regularly break user's code.  In reaching 1.0, we began releasing versions that maintained backwards compatibility with 1.0.  For stable Rust, 83.6% of users did not experience any breakage in their project as they upgraded to the next stable version.  Previous research based on automated testing against the ecosystem put this number [closer to 96%](https://internals.rust-lang.org/t/rust-regressions-2015-year-end-report/2993), which is more in line with expectations.
 
 Why the discrepancy? Looking at the data more closely, it seems people used this question as a catch-all for any kind of breakage, including packages in cargo, compiler plugins needing updates, and the changes to libc.  We'll be sure to word this question more clearly in the future. But we also plan to launch a forum discussion digging further into the details, to make sure that there’s not something missing from the test automation that runs against crates.io.
 
-![Fixing broken code][easy_to_fix]{:class="center"}
+![Fixing broken code][easy_to_fix]
 
 Luckily, regardless of what bucket the breakage fell into, they were largely easy to solve as people upgraded.
 
-![Do you like Cargo][like_cargo]{:class="center"}
+![Do you like Cargo][like_cargo]
 
 Another big piece of the Rust development experience is using the Cargo tool.  Here we saw overwhelming support for Cargo, with 94.1% of people saying they would rate it a 4 or 5.  This helps to emphasize that Cargo continues to be a core part of what it means to write Rust (and that people enjoy using it!)
 
 ## Rust at Work
 
 An important part of a programming language's success is that it's used for "real" work.  We asked a few questions to understand how Rust was doing in the workplace.  Were people using it in their day jobs?  How much was it being used?
 
-![Using Rust at work][rust_at_work]{:class="center"}
+![Using Rust at work][rust_at_work]
 
 We were pleasantly surprised to see that already, in Rust's first year, 16.1% of Rust users are using Rust at work part-time and 3.7% are using at work full-time.  Combined, **nearly 1/5th of Rust users are using Rust commercially**.  We're seeing this reflected in the growing number of [companies using Rust](https://www.rust-lang.org/friends.html).
 
 We also asked about the size of the codebases that Rust developers were building.
 
-![Size of part-time codebases][part_time]{:class="center"}
+![Size of part-time codebases][part_time]
 
-![Size of full-time codebases][full_time]{:class="center"}
+![Size of full-time codebases][full_time]
 
 We see strong numbers in project size as developers put more time into Rust at work.  Over half of the Rust users using Rust full-time at work have codebases that are tens or hundreds of thousands of lines of code.
 
 Equally encouraging is the growth we expect to see in Rust in the workplace, as we see in the next chart.
 
-![Using Rust at work in future][rust_at_work_future]{:class="center"}
+![Using Rust at work in future][rust_at_work_future]
 
 Of those not currently using Rust at work, more than 40% plan on being able to use Rust at work.  This will help carry Rust to more places and in more areas.  Speaking of carrying to more areas, we saw a wide variety of job domains represented in the survey:
 
-![Demographics of work areas][demo_areas]{:class="center"}
+![Demographics of work areas][demo_areas]
 
 It's encouraging to see people from so many different backgrounds interested in Rust.  It underscores Rust’s potential across a broad spectrum of programming tasks and the need for libraries to support these areas.
 
@@ -128,17 +128,17 @@ We've also been investing in other tooling muscles, including a [new installer w
 
 ## Survey Demographics
 
-![Popular meetup locations][meetup_locations]{:class="center"}
+![Popular meetup locations][meetup_locations]
 
 Today, Rust has a worldwide audience.  Rather than being lumped in one place, we see Rust users in Europe, Japan, Australia, with new meetups popping up everyday.  We also asked where people who responded lived, and over 1000 of the 3000 survey responses mentioned living in Europe (with USA following it up at 835).
 
-![Demographics on programming language background][what_languages]{:class="center"}
+![Demographics on programming language background][what_languages]
 
 The parents of most modern languages, C and C++, show strongly in terms of the programming languages that people are most comfortable with.  Close by are Java and JavaScript.  Perhaps one surprising point here is the large number of Python users attracted to Rust.
 
 For those who already have existing projects in other languages but want to use Rust, it's worth mentioning here the on-going efforts to aide in using Rust with other languages, including work to [integrate with Ruby](https://github.com/rustbridge/helix) and [integrate with JavaScript/Node.js](https://github.com/rustbridge/neon).
 
-![Members of underrepresented groups][underrepresented]{:class="center"}
+![Members of underrepresented groups][underrepresented]
 
 Rust strives to be a [warm, welcoming and inclusive community](https://www.rust-lang.org/conduct.html). The survey shows that, despite that spirit, we have a ways to go in terms of diversity. We have nascent efforts, like [RustBridge](https://github.com/rust-community/rustbridge), to more proactively reach out to underrepresented groups and make Rust more accessible, but there is a lot more work to be done.  We'll be watching the results of this part of the survey closely and continue to invest in outreach, mentoring, and leadership to foster inclusivity.
 

diff --git a/posts/2016-09-08-incremental.md b/posts/2016-09-08-incremental.md
@@ -110,7 +110,7 @@ time with a different value for `a`. For the first time around, `a` will be
      /     /   \
     a=1   b=2  c=3
 -->
-![Initial Computation of a+b×c][algebra-initial]{:class="center"}
+![Initial Computation of a+b×c][algebra-initial]
 
 Assume that we "saved" the intermediate results at each step, that is, we
 remember somewhere that `b×c` is `6` and `a+b×c` is `7`. Now, in the second
@@ -129,7 +129,7 @@ entire, tedious multiplication.
     a=4   b=2  c=3
 -->
 
-![Updating the Computation][algebra-update]{:class="center"}
+![Updating the Computation][algebra-update]
 
 Let's see how this scheme translates to the compiler.
 
@@ -158,7 +158,7 @@ produce:
     >===========>===============>===========>===========>
         parse       analysis       codegen     linking
 -->
-![Compiler Phases and their By-Products][compiler-phases]{:class="center"}
+![Compiler Phases and their By-Products][compiler-phases]
 
 First the compiler will parse the source code into an abstract syntax tree
 (AST). The AST then goes through the analysis phase which produces type
@@ -214,7 +214,7 @@ practice:
      /    /   \
     a    b     c
 -->
-![Dependency Graph of a+b×c][algebra-dep-graph]{:class="center"}
+![Dependency Graph of a+b×c][algebra-dep-graph]
 
 As you can see, we have nodes for the inputs `a`, `b`, and `c`, and nodes for
 the intermediate results `b×c` and `a+b×c`. The edges should come as no
@@ -232,7 +232,7 @@ add another intermediate result `b×c+c` to our computation:
      /    /   \ /
     a    b     c
 -->
-![Example of a non-tree Dependency Graph][algebra-dep-graph-dag]{:class="center"}
+![Example of a non-tree Dependency Graph][algebra-dep-graph-dag]
 
 What makes this data structure really useful is that we can ask it questions
 of the form "if X has changed, is Y still up-to-date?". We just take the node
@@ -271,7 +271,7 @@ have all our data nicely linked up, mostly automatically:
         parse       analysis       codegen     linking
 -->
 
-![Dependency Graph of Compilation Data][compiler-dep-graph]{:class="center"}
+![Dependency Graph of Compilation Data][compiler-dep-graph]
 
 This dependency graph is then stored in the incremental compilation cache
 directory along with the cache entries it describes.
@@ -291,7 +291,7 @@ are not up-to-date anymore and just remove them from the cache:
     >===========>===============>===========>===========>
         parse       analysis       codegen     linking
 -->
-![Using the Dependency Graph to Validate the Incremental Compilation Cache][compiler-cache-purge]{:class="center"}
+![Using the Dependency Graph to Validate the Incremental Compilation Cache][compiler-cache-purge]
 
 Anything that has survived this cache validation phase can safely be re-used
 during the current compilation session.
@@ -355,7 +355,7 @@ much time is spent in each one on average:
 
 TIME:    5%            20%         **65%**       10%
 -->
-![Relative Cost of Compilation Phases][compiler-phases-cost]{:class="center"}
+![Relative Cost of Compilation Phases][compiler-phases-cost]
 
 As you can see, the Rust compiler spends most of its time in the optimization
 and codegen passes. Consequently, if this phase can be skipped at least for
@@ -384,7 +384,7 @@ of a crate's object files can be re-used. This might occur when changing one
 crate in a multi-crate project and downstream crates need to be rebuilt but
 are not really affected.
 
-![Normalized Incremental Compilation Build Times][performance-full-re-use]{:class="center"}
+![Normalized Incremental Compilation Build Times][performance-full-re-use]
 
 As you can see, compiling a crate for the first time in incremental mode can be
 slower than compiling it in non-incremental mode. This is because the dependency
@@ -409,7 +409,7 @@ scratch.
 The next graph shows which impact various changes made to the `regex` crate
 have on incremental rebuild times:
 
-![Build Times After Specific Changes][performance-changes]{:class="center"}
+![Build Times After Specific Changes][performance-changes]
 
 The numbers show that the effectiveness of incremental compilation indeed depends a
 lot on the type of change applied to the code. For changes with very local

diff --git a/posts/2017-05-15-rust-at-two-years.md b/posts/2017-05-15-rust-at-two-years.md
@@ -11,7 +11,7 @@ ambitions of dyed-in-the-wool systems hackers.
 
 It's been two years since Rust 1.0 was released. Happy second birthday, Rust!
 
-![Group picture from RustFest Berlin][group-pic]{:class="center"}
+![Group picture from RustFest Berlin][group-pic]
 
 *Rustaceans at RustFest Berlin, September 2016. Picture by Fiona Castiñeira*
 
@@ -231,7 +231,7 @@ release mode will often be **five times as fast** with incremental compilation!
 This graph shows the improvements in compilation time when making changes to
 various parts of the regex crate and rebuilding in release mode:
 
-![Graph showing improved time with incremental compilation][incrcomp-svg]{:class="center"}
+![Graph showing improved time with incremental compilation][incrcomp-svg]
 
 Try out incremental compilation on nightly Rust with
 `CARGO_INCREMENTAL=1 cargo <command>`!

diff --git a/posts/2017-06-27-Increasing-Rusts-Reach.md b/posts/2017-06-27-Increasing-Rusts-Reach.md
@@ -84,15 +84,15 @@ Who should apply for this project:
 - Interest in improving usability of developer-facing documentation and tools
 - Interest in learning in detail about Rust syntax and semantics
 
-![Nick Cameron][nrc]{:class="right-thumbnail"}
+![Nick Cameron][nrc]
 
 *About Nick Cameron: I'm a Rust core team member and lead the dev-tools team. I work on a bunch of
 tools including Rustdoc, Rustfmt, the Rust Language Server, and the Rust compiler. I want to make
 Rust developer tools awesome, and user experience is a key part of that. I want Rust to change the
 world (or at least the programming world), and we can't do that without making the Rust language
 and community more accessible to more people.*
 
-![Steve Klabnik][steveklabnik]{:class="right-thumbnail"}
+![Steve Klabnik][steveklabnik]
 
 *About Steve Klabnik: I used to work on Ruby on Rails before Rust, and one of the reasons why I love
 Rust is that as a project, we're committed to helping people learn Rust as their first low-level
@@ -127,7 +127,7 @@ Who should apply for this project:
 - Interest in improving the new Rust developer experience
 - Interest in learning how to improve and create lints
 
-![Manish Goregaokar][manishearth]{:class="right-thumbnail"}
+![Manish Goregaokar][manishearth]
 
 *About Manish Goregaokar: I'm a research engineer at Mozilla working on Servo. I care a lot about
 improving workflows and tooling, especially around the newcomer experience.*
@@ -154,7 +154,7 @@ Who should apply for this project:
 - Interest in improving approachability of Rust
 - Interest in investigating the motivations behind visitors to the main website and/or crates.io
 
-![Aaron Turon][aturon]{:class="right-thumbnail"}
+![Aaron Turon][aturon]
 
 *About Aaron Turon: I'm a Rust core team member, manage the Mozilla Rust team, and currently lead
 the library, infrastructure, and Cargo teams. On the technical side, I'm most driven by language
@@ -181,7 +181,7 @@ Who should apply for this project:
 - Background or interest in creating visual teaching tools like diagrams or drawings a plus
 - Interest in learning Rust concepts and teaching what you learn to others
 
-![Niko Matsakis][nmatsakis]{:class="right-thumbnail"}
+![Niko Matsakis][nmatsakis]
 
 *About Niko Matsakis: I'm a member of the Rust core team as well as the Rust language and compiler
 teams. I focus mainly on the design and implementation of the language itself. I want to do what I
@@ -205,7 +205,7 @@ Who should apply for this project:
 - Experience using a web framework written in some other language
 - Interest in learning how to write web applications in Rust and teaching what you learn to others
 
-![Sean Griffin][sgrif]{:class="right-thumbnail"}
+![Sean Griffin][sgrif]
 
 *About Sean Griffin: In addition to my Rust work, I am one of the maintainers of Ruby on Rails. One
 of the great things about Rails (and web development) is that it has really helped to lower the
@@ -235,7 +235,7 @@ Who should apply for this project:
 - Background in writing, teaching, or documentation
 - Interest in, and opinions about, improving tools for creating and displaying code documentation
 
-![Felix Klock][pnkfelix]{:class="right-thumbnail"}
+![Felix Klock][pnkfelix]
 
 *About Felix Klock: I'm the main developer of tango (as well as a member of the Rust compiler and
 language teams). I actively use tango for authoring my presentation slides about Rust. I
@@ -267,7 +267,7 @@ Who should apply for this project:
 - Interest in learning how to translate an application to Rust
 - Interest in researching and documenting features that libraries have or don’t have
 
-![Andrew Gallant][burntsushi]{:class="right-thumbnail"}
+![Andrew Gallant][burntsushi]
 
 *About Andrew Gallant: I'm a member of the Rust library team that works with Rust in my free time. I
 am very interested in information retrieval, fast text search and generally improving Rust's
@@ -293,7 +293,7 @@ Who should apply for this project:
 - Interest in learning how to write or translate a CLI program to Rust
 - Interest in researching and documenting features that libraries have or don’t have
 
-![Kamal Marhubi][kamalmarhubi]{:class="right-thumbnail"}
+![Kamal Marhubi][kamalmarhubi]
 
 *About Kamal Marhubi: I've been writing Rust for about a year and a half. I help maintain nix, a
 library that gives a Rusty interface to unix systems APIs. I've also contributed to rustfmt, rustup,

diff --git a/posts/2017-12-21-rust-in-2017.md b/posts/2017-12-21-rust-in-2017.md
@@ -32,7 +32,7 @@ There’s not room in a single post to cover everything that happened, but we’
   - You can see how incremental recompilation performs in practice on some of our key benchmarks below. Note that `-opt` refers to optimized builds, “best case” refers to a recompilation with no changes, and `println` refers to a recompilation with a small change, like adding a `println` call to a function body. We expect the 50+% speedups we’re seeing now to continue to grow next year as we push incremental recompilation more deeply through the compiler.
   - Together with the changes in the compiler we will also update Cargo to use incremental recompilation by default for select use cases, so you can take advantage of improved compile times without the need for additional configuration. Of course you will also be able to opt into and out of the feature on a case by case basis as you see fit.
 
-![Incremental recompilation benchmarks](/images/2017-12-Retro/incr-bench.png){:class="center"}
+![Incremental recompilation benchmarks](/images/2017-12-Retro/incr-bench.png)
 
 ## Rust should provide a solid, but basic IDE experience
 

diff --git a/posts/2018-05-15-Rust-turns-three.md b/posts/2018-05-15-Rust-turns-three.md
@@ -36,7 +36,7 @@ teams, and just under half of the total number of people paid to work on
 Rust. (You can read detailed whitepapers about putting Rust into
 production [here](https://www.rust-lang.org/en-US/whitepapers.html).)
 
-![Graphs of Rust team growth][team]{:class="center"}
+![Graphs of Rust team growth][team]
 
 [team]: /images/2018-05-Third-Birthday/team.png