diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 093d3af8ee..dfefcd5b90 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -82,8 +82,8 @@
     - [File hierarchy](mod/split.md)
 
 - [Crates](crates.md)
-    - [Library](crates/lib.md)
-    - [`extern crate`](crates/link.md)
+    - [Creating a Library](crates/lib.md)
+    - [Using a Library](crates/using_lib.md)
 
 - [Cargo](cargo.md)
     - [Dependencies](cargo/deps.md)
diff --git a/src/crates/lib.md b/src/crates/lib.md
index 20b4cac59e..44593f3bb0 100644
--- a/src/crates/lib.md
+++ b/src/crates/lib.md
@@ -1,4 +1,4 @@
-# Library
+# Creating a Library
 
 Let's create a library, and then see how to link it to another crate.
 
diff --git a/src/crates/link.md b/src/crates/link.md
deleted file mode 100644
index 828fbdbeba..0000000000
--- a/src/crates/link.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# `extern crate`
-
-To link a crate to this new library, the `extern crate` declaration must be
-used. This will not only link the library, but also import all its items under
-a module named the same as the library. The visibility rules that apply to
-modules also apply to libraries.
-
-```rust,ignore
-// Link to `library`, import items under the `rary` module
-extern crate rary;
-
-fn main() {
-    rary::public_function();
-
-    // Error! `private_function` is private
-    //rary::private_function();
-
-    rary::indirect_access();
-}
-```
-
-```txt
-# Where library.rlib is the path to the compiled library, assumed that it's
-# in the same directory here:
-$ rustc executable.rs --extern rary=library.rlib && ./executable
-called rary's `public_function()`
-called rary's `indirect_access()`, that
-> called rary's `private_function()`
-```
diff --git a/src/crates/using_lib.md b/src/crates/using_lib.md
new file mode 100644
index 0000000000..102080700f
--- /dev/null
+++ b/src/crates/using_lib.md
@@ -0,0 +1,27 @@
+# Using a Library
+
+To link a crate to this new library you may use `rustc`'s `--extern` flag. All 
+of its items will then be imported under a module named the same as the library.
+This module generally behaves the same way as any other module.
+
+```rust,ignore
+// extern crate rary; // May be required for Rust 2015 edition or earlier
+
+fn main() {
+    rary::public_function();
+
+    // Error! `private_function` is private
+    //rary::private_function();
+
+    rary::indirect_access();
+}
+```
+
+```txt
+# Where library.rlib is the path to the compiled library, assumed that it's
+# in the same directory here:
+$ rustc executable.rs --extern rary=library.rlib --edition=2018 && ./executable 
+called rary's `public_function()`
+called rary's `indirect_access()`, that
+> called rary's `private_function()`
+```
diff --git a/src/mod/use.md b/src/mod/use.md
index 8860bc20b4..7a57272b15 100644
--- a/src/mod/use.md
+++ b/src/mod/use.md
@@ -4,8 +4,6 @@ The `use` declaration can be used to bind a full path to a new name, for easier
 access. It is often used like this:
 
 ```rust,editable,ignore
-// extern crate deeply; // normally, this would exist and not be commented out!
-
 use crate::deeply::nested::{
     my_first_function,
     my_second_function,
diff --git a/src/testing/integration_testing.md b/src/testing/integration_testing.md
index 2ab0d85a6e..a4345ae945 100644
--- a/src/testing/integration_testing.md
+++ b/src/testing/integration_testing.md
@@ -10,7 +10,7 @@ Cargo looks for integration tests in `tests` directory next to `src`.
 File `src/lib.rs`:
 
 ```rust,ignore
-// Assume that crate is called adder, will have to extern it in integration test.
+// Define this in a crate called `adder`.
 pub fn add(a: i32, b: i32) -> i32 {
     a + b
 }
@@ -19,9 +19,6 @@ pub fn add(a: i32, b: i32) -> i32 {
 File with test: `tests/integration_test.rs`:
 
 ```rust,ignore
-// extern crate we're testing, same as any other code would do.
-extern crate adder;
-
 #[test]
 fn test_add() {
     assert_eq!(adder::add(3, 2), 5);
@@ -66,9 +63,6 @@ pub fn setup() {
 File with test: `tests/integration_test.rs`
 
 ```rust,ignore
-// extern crate we're testing, same as any other code will do.
-extern crate adder;
-
 // importing common module.
 mod common;