├── README.md ├── basic-syntax.html ├── getting-started.html ├── index.html ├── strings.html ├── styles.css └── template.html /README.md: -------------------------------------------------------------------------------- 1 | # Rust in Ten Slides 2 | 3 | This is an experiment to produce short, useful documentation for the Rust 4 | programming language. 5 | 6 | Here's the idea: take a concept in Rust, and make ten slides about it. Ten 7 | slides is short enough to be easy to make and easy to consume, but long 8 | enough to get some kind of point across. 9 | 10 | If this is successful, I'd like to upstream it into the main Rust docs. 11 | 12 | This project is inspired by [A very brief intro to 13 | Rust](https://github.com/ashleygwilliams/a-very-brief-intro-to-rust). After 14 | seeing students write code after only looking at these slides, I think 15 | expanding on this idea might bear some interesting fruit! 16 | 17 | ## How it works 18 | 19 | 1. Copy `template.html` into a new file, name it after the topic of your 20 | presentation; for example, `strings.html`. 21 | 2. Slides are written in Markdown inside the file using [Remark](https://remarkjs.com/#1), 22 | check that link for examples of the syntax. 23 | 3. Open the file in your web browser to see the presentation in action! 24 | 4. Modify `index.html` to include your new presentation. 25 | 5. Send me a pull request! 26 | 27 | ## License 28 | 29 | Everything is licensed under MIT/Apache2, just like Rust. -------------------------------------------------------------------------------- /basic-syntax.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Rust in ten slides 5 | 6 | 7 | 8 | 9 |

10 | class: middle, center
 11 | 
 12 | # Basic Rust Syntax
 13 | 
 14 | ### This presentation will give you a quick overview of basic Rust syntax
 15 | 
 16 | ---
 17 | class: middle, left
 18 | 
 19 | # Variables
 20 | 
 21 | `let` introduces new variables:
 22 | 
 23 | ```rust
 24 | let x = 5;
 25 | ```
 26 | 
 27 | Variables are immutable by default
 28 | 
 29 | ```rust
 30 | let x = 5;
 31 | x += 1;
 32 | ```
 33 | 
 34 | ```text
 35 | error[E0384]: cannot assign twice to immutable variable `x`
 36 |   |     let x = 5;
 37 |   |         - first assignment to `x`
 38 |   |     x += 1;
 39 |   |     ^^^^^^ cannot assign twice to immutable variable
 40 | ```
 41 | 
 42 | in order to modify them, you need to say
 43 | they're `mut`able:
 44 | 
 45 | ```rust
 46 | let mut x = 5;
 47 | x += 1;
 48 | ```
 49 | 
 50 | ---
 51 | class: middle, left
 52 | 
 53 | # Basic Types
 54 | 
 55 | Rust is statically typed, but infers types for you. You can write them out if you'd like:
 56 | 
 57 | ```rust
 58 | let x = 5;
 59 | let x: i32 = 5;
 60 | ```
 61 | 
 62 | Rust has a few primitive types:
 63 | 
 64 | * **Booleans**: are *true* and *false*
 65 | * **Integers**: are both signed and unsigned. *u8*/*i8*, *u16*/*i16*, *u32*/*i32*, *u64*/*i64*, and *u128*/*i128*.
 66 | * **Floating point numbers**:, *f32* and *f64*
 67 | * **Tuples**: are for grouping different types together *(i32, f64, i8)*
 68 | * **Arrays**: that are fixed size *[u32; 3]* is the type of *[1, 2, 3]*
 69 | * **References**: like pointers but safer. *&i32* is the type of *&5*
 70 | * **Slices**: refer to parts of an array *&[u8]*
 71 | * **char**: is a single Unicode Scalar Value, and uses single quotes *'🦀'*
 72 | * **&str**: is an immutable UTF-8 string *"this is a crab: 🦀"*
 73 | 
 74 | ---
 75 | class: middle, left
 76 | 
 77 | # Functions
 78 | 
 79 | Here's a small function that adds one to a number:
 80 | 
 81 | ```rust
 82 | fn add_one(x: i32) -> i32 {
 83 |     x + 1
 84 | }
 85 | ```
 86 | 
 87 | * `fn` declares a function, and the name `add_one` follows.
 88 | * `()`s show you the parameter list; you must write the names and types of your parameters; Rust won't infer these!
 89 | * The arrow `->` gives the return type. You can only return one thing, but don't forget, tuples work: `-> (i32, i32)`
 90 | * The body goes inside curly braces `{}`, and lines end with a semicolon `;`
 91 | * "everything is an expression"; so the last line is the return value, no `;`.
 92 | 
 93 | You can use `return` explicitly if you prefer, or to return early:
 94 | 
 95 | ```rust
 96 | fn add_one(x: i32) -> i32 {
 97 |     return x + 1;
 98 | }
 99 | ```
100 | 
101 | ---
102 | class: middle, left
103 | 
104 | # Printing to the Screen
105 | 
106 | The `println!` macro will let you print to the screen:
107 | 
108 | ```rust
109 | println!("Hello, world!");
110 | ```
111 | 
112 | You can do formatted print with `{}`:
113 | 
114 | ```rust
115 | println!("Here's a number: {} and another: {}", 42, 100);
116 | ```
117 | 
118 | You can debug print with `{:?}`:
119 | 
120 | ```rust
121 | println!("Display: {}", "hello"); // prints "Display: hello"
122 | println!("Debug: {:?}", "hello"); // prints "Debug: "hello""
123 | ```
124 | 
125 | ---
126 | class: middle, left
127 | 
128 | # Comments
129 | 
130 | Rust has two main kinds of comments.
131 | 
132 | Regular comments for your own use:
133 | 
134 | ```rust
135 | // Put whatever you'd like here, Rust doesn't care
136 | ```
137 | 
138 | And doc comments:
139 | 
140 | ```rust
141 | /// This comment documents the `foo` function.
142 | ///
143 | /// You can use the `rustdoc` tool via `cargo doc` to generate
144 | /// HTML documentation from these comments!
145 | fn foo() {
146 |     // ...
147 | }
148 | ```
149 | 
150 | ---
151 | class: middle, left
152 | 
153 | # `if` expressions
154 | 
155 | The `if` expression lets you do something if something is true or false,
156 | and `else` is there too:
157 | 
158 | ```rust
159 | if something {
160 |     println!("it was true!");
161 | } else {
162 |     println!("it was false");
163 | }
164 | ```
165 | 
166 | Because `if` is an expression, you can use it in all kinds of places:
167 | 
168 | ```rust
169 | let power = if too_powerful { 0 } else { 100 };
170 | ```
171 | 
172 | Now `power` will be `0` or `100` based on the `too_powerful` variable's value.
173 | 
174 | ---
175 | class: middle, left
176 | 
177 | # `for` and `while` Loops
178 | 
179 | `for` loops will let you iterate over a range or collection:
180 | 
181 | ```rust
182 | for i in 0..5 {
183 |     println!("{}", i);
184 | }
185 | 
186 | let list = [1, 5, 3, 17];
187 | 
188 | for i in &list {
189 |     println!("{}", i);
190 | }
191 | ```
192 | 
193 | `while` loops loop until a condition is met:
194 | 
195 | ```rust
196 | let mut done = false;
197 | let mut i = 0;
198 | 
199 | while !done {
200 |     // do stuff with i
201 |     if i > 5 { done = true; }
202 | }
203 | ```
204 | 
205 | ---
206 | class: middle, left
207 | 
208 | # Structs and enums
209 | 
210 | Structs let you group multiple primitive types together into one big type:
211 | 
212 | ```rust
213 | struct Point {
214 |     x: i32,
215 |     y: i32,
216 | }
217 | 
218 | let origin = Point {
219 |     x: 0,
220 |     y: 0,
221 | };
222 | ```
223 | 
224 | Enums are similar, but you can only have one of the variants at a time:
225 | 
226 | ```rust
227 | enum TrafficLight {
228 |     Green,
229 |     Yellow,
230 |     Red,
231 | }
232 | 
233 | let light = TrafficLight::Green;
234 | ```
235 | 
236 | Enums are way more powerful than this, but that's for another set of slides!
237 | 
238 | ---
239 | class: middle, left
240 | 
241 | # Methods
242 | 
243 | Methods are like functions, but take a special `self` parameter and can be called with method syntax:
244 | 
245 | ```rust
246 | struct Point {
247 |     x: i32,
248 |     y: i32,
249 | }
250 | 
251 | impl Point {
252 |     fn print(&self) {
253 |         println!("({}, {})", self.x, self.y);
254 |     }
255 | }
256 | 
257 | let origin = Point { x: 0, y: 0 };
258 | 
259 | point.print(); // prints "(0, 0)"
260 | ```
261 |

262 | 264 | 267 | 268 | 269 | 270 | -------------------------------------------------------------------------------- /getting-started.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Rust in ten slides 5 | 6 | 7 | 8 | 9 |

10 | class: middle, center
 11 | 
 12 | # Getting started with Rust
 13 | 
 14 | ### This presentation will help you get Rust installed, demonstrate some neat tools, and show you "hello world"
 15 | 
 16 | ---
 17 | class: middle, left
 18 | 
 19 | ## Installing Rust
 20 | 
 21 | The best way to install Rust is with [rustup](https://www.rustup.rs/), a Rust
 22 | version manager. To install it type:
 23 | 
 24 | ```bash
 25 | $ curl https://sh.rustup.rs -sSf | sh
 26 | ```
 27 | 
 28 | To keep your rust up-to-date with the latest release of rust,
 29 | type:
 30 | 
 31 | ```bash
 32 | $ rustup update
 33 | ```
 34 | 
 35 | To check which version of Rust you have type:
 36 | 
 37 | ```bash
 38 | $ rustc --version
 39 | ```
 40 | 
 41 | ---
 42 | class: middle, left
 43 | 
 44 | ## cargo
 45 | 
 46 | Cargo is a tool that helps you develop Rust programs. It does several things:
 47 | 
 48 | - Runs tasks: `cargo build` (compile your app), `cargo test` (test your app), `cargo run` (run your app)
 49 | - Start a project: `cargo new`, `cargo init`
 50 | 
 51 | Cargo is also the package manager for Rust. This means that you can
 52 | use Cargo to install and manage bits of other people's code.
 53 | 
 54 | - A program or library is called a "crate".
 55 | - A package contains one or more crates.
 56 | - You can find Crates on http://crates.io
 57 | - You list the Crates you want to use in the `Cargo.toml` file
 58 | - Your app keeps track of what crates you are using in the `Cargo.lock` file
 59 | 
 60 | ---
 61 | class: middle, left
 62 | 
 63 | ## Setting up a Project
 64 | 
 65 | Creating a new project is easy!
 66 | 
 67 | 1. Type `cargo new --bin name-of-my-project`
 68 |   * Use `--lib` if you are writing a library
 69 | 2. `cd` into the new `name-of-my-project` directory
 70 | 
 71 | This will create several files and folders for you automatically:
 72 | 
 73 | - `Cargo.toml`: metadata about your project and its dependencies
 74 | - `.gitignore`: ignores compiled files built by Rust
 75 | - `src/lib.rs` or `src/main.rs`: where your Rust code goes
 76 | 
 77 | ---
 78 | class: middle, left
 79 | 
 80 | ## `lib.rs` vs `main.rs`
 81 | 
 82 | There are 2 main types of projects you can make in Rust: a library and not
 83 | a library.
 84 | 
 85 | If you are writing a <strong>library</strong>, it means you intend for your
 86 | code to be used in someone else's application as a crate or module.
 87 | If you want to do this, you should use a `lib.rs`.
 88 | 
 89 | If you are writing a <strong>not library</strong>, it means that you'd like
 90 | to write code that compiles into a binary that someone can run. If you
 91 | want to do this, you need to use a `main.rs`. Inside the `main.rs` you
 92 | should have a `main` function that looks like this:
 93 | 
 94 | ```rust
 95 | fn main() {
 96 |   // your app code goes here
 97 | }
 98 | ```
 99 | 
100 | ---
101 | class: middle, left
102 | 
103 | ## `rustfmt`
104 | 
105 | The `rustfmt` tool integrates with Cargo and can format your code for you! To
106 | install it:
107 | 
108 | ```bash
109 | $ rustup component add rustfmt-preview
110 | ```
111 | 
112 | And to use it:
113 | 
114 | ```bash
115 | $ cargo fmt
116 | ```
117 | 
118 | Cargo will re-write your files with the newly formatted code.
119 | 
120 | ---
121 | class: middle, left
122 | 
123 | ## Hello, world!
124 | 
125 | If you generate a new program:
126 | 
127 | ```bash
128 | $ cargo new hello-world
129 | $ cd hello-world
130 | ```
131 | 
132 | Cargo will make `src/main.rs` a "Hello World" program for you!
133 | 
134 | ```rust
135 | fn main() {
136 |     println!("Hello, world!");
137 | }
138 | ```
139 | 
140 | Remember, you can run it with `cargo run`:
141 | 
142 | ```bash
143 | $ cargo run
144 |     Compiling hello-world v0.1.0 (file:///C:/hello-world)
145 | Finished dev [unoptimized + debuginfo] target(s) in 2.6 secs
146 |  Running `target\debug\hello-world.exe`
147 | Hello, world!
148 | ```
149 | 
150 | ---
151 | class: middle, left
152 | 
153 | ## Basic Syntax
154 | 
155 | If we look at "hello world":
156 | 
157 | ```rust
158 | fn main() {
159 |     println!("Hello, world!");
160 | }
161 | ```
162 | 
163 | * `fn` declares a function. In this case, our function is named `main`. `main` will
164 |   be called when your program starts.
165 | * The empty parenthesis means that `main` takes no parameters.
166 | * Function bodies go in curly braces: `{}`
167 | * The `println!` macro (the `!` means it's a macro) prints stuff to the screen!
168 | * Strings go inside double quotes `""`
169 | * Lines end with a semicolon `;`
170 | 
171 | Try adding another call to `println!` with a second message!
172 | 
173 | ---
174 | class: middle, left
175 | 
176 | ## `cargo check`
177 | 
178 | If you want the compiler to check your work, but you don't plan on actually running
179 | your program, you can use `cargo check`. It's faster than `cargo build`:
180 | 
181 | ```bash
182 | $ cargo build
183 |    Compiling hello-world v0.1.0 (file:///C:/hello-world)
184 |     Finished dev [unoptimized + debuginfo] target(s) in 1.21 secs
185 | $ cargo check
186 |    Compiling hello-world v0.1.0 (file:///C:/hello-world)
187 |     Finished dev [unoptimized + debuginfo] target(s) in 0.85 secs
188 | ```
189 | 
190 | For "hello world" that's not much, but on real projects it really adds up!
191 | 
192 | ---
193 | class: middle, left
194 | 
195 | ## Learning More
196 | 
197 | There are other "Rust in ten slides" presentations too, but you
198 | may also find these resources useful!
199 | 
200 | - The Rust Docs, https://doc.rust-lang.org/
201 | - The Rust Book, https://doc.rust-lang.org/book/
202 | - into_rust Screencasts, http://intorust.com/
203 | - The Rust Play Ground, https://play.rust-lang.org/
204 | - Rust by Example, http://rustbyexample.com/
205 | - Rust on exercism.io, http://exercism.io/languages/rust
206 | - New Rustacean Podcast, http://www.newrustacean.com/
207 |       
208 |

209 | 211 | 214 | 215 | 216 | 217 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Rust in ten slides 6 | 7 | 22 | 23 | 24 | 25 |

Rust in ten slides

26 | 27 |

This is an experiment to produce short, useful documentation for the Rust 28 | programming language.

29 | 30 |

Here's the idea: take a concept in Rust, and make ten slides about it. Ten 31 | slides is short enough to be easy to make and easy to consume, but long 32 | enough to get some kind of point across.

33 | 34 |

If this is successful, I'd like to upstream it into the main Rust docs.

35 | 36 |

Here's what I've got so far:

37 | 38 |

43 | 44 |

If you'd like to contribute some slides, please check this out on GitHub.

45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /strings.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Rust in ten slides 5 | 6 | 7 | 8 | 9 |

10 | class: middle, center
 11 | 
 12 | # Strings in Rust
 13 | 
 14 | ### Learn a bunch about strings
 15 | 
 16 | ---
 17 | class: middle, left
 18 | 
 19 | ## `char`, the primitive character type
 20 | 
 21 | Rust has a primitive type for a single character, `char`.
 22 | 
 23 | ```rust
 24 | let heart = '❤';
 25 | ```
 26 | 
 27 | However, this isn't *technically* a character, but a [Unicode Scalar
 28 | Value](https://www.unicode.org/glossary/#unicode_scalar_value). This means
 29 | that some things are a single `char`, but others aren't:
 30 | 
 31 | ```rust
 32 | let eye_in_speech_bubble = '👁️‍🗨️';
 33 | ```
 34 | 
 35 | ```bash
 36 | error: character literal may only contain one codepoint
 37 |  --> src/main.rs:2:32
 38 |   |
 39 | 2 |     let eye_in_speech_bubble = '👁️‍🗨️';
 40 |   |                                ^^^^
 41 | ```
 42 | 
 43 | What looks like a character to you may not be one to Unicode. More on this later.
 44 | This also means that `char` is *always* four bytes, not one like in C.
 45 | 
 46 | ---
 47 | class: middle, left
 48 | 
 49 | # `&str` the primitive "string slice"
 50 | 
 51 | Rust also has a built-in string type: `&str`:
 52 | 
 53 | ```rust
 54 | let s = "hello world";
 55 | ```
 56 | 
 57 | `&str`s are immutable, and are, under the hood, a pointer to the start of the
 58 | string, and a length. This means we can slice up strings without allocating
 59 | new ones!
 60 | 
 61 | ```rust
 62 | let s = "hello world";
 63 | let hello = &s[..5]; // "hello"
 64 | let world = &s[6..]; // "world"
 65 | ```
 66 | 
 67 | Both `hello` and `world` are new `&str`s that refer to the first one, `s`.
 68 | 
 69 | > Note: A range like `..5` means "from the start to index 5" and one like
 70 | > `2..` means "from index 2 till the end".
 71 | 
 72 | ---
 73 | class: middle, left
 74 | 
 75 | # A bit about UTF-8
 76 | 
 77 | Strings in Rust are UTF-8 encoded, and contain a lot of Unicode-based functionality out of the box.
 78 | 
 79 | However, UTF-8 is a variable-width encoding. This means that a `&str` is **not** a list of `char`,
 80 | like you might assume at first. `char`s are four bytes each, so for example, consider this string:
 81 | 
 82 | ```rust
 83 | let s = "hi";
 84 | ```
 85 | 
 86 | Here's how it'd be laid out in memory, both as `&str` is, and if `&str` were made up of `char`s:
 87 | 
 88 | | index  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
 89 | |--------|---|---|---|---|---|---|---|---|
 90 | | `&str` | h | i |   |   |   |   |   |   |
 91 | | `char` | 0 | 0 | 0 | h | 0 | 0 | 0 | i |
 92 | 
 93 | The `&str` is only two bytes, but the list of `char` would be eight!
 94 | 
 95 | ---
 96 | class: middle, left
 97 | 
 98 | ### `String` is an owned mutable string
 99 | 
100 | If you need to modify some string data, you'll want to create a `String`.
101 | 
102 | There are... a lot of ways to do this, as strings implement a ton of traits:
103 | 
104 | * `s.to_string()` is considered idiomatic, as it's very direct
105 | * `String::from(s)` is sometimes used with literals, as it looks nicer
106 | * `s.to_owned()` works too, as `String` is the owned variant of `&str`
107 | * `s.into()` can work as well, since everything that implements `From` implements `Into`
108 | 
109 | ```rust
110 | // this works
111 | let mut s = "hello".to_string();
112 | 
113 | // so does this
114 | let mut s = String::from("hello");
115 | 
116 | s.push_str(" world");
117 | 
118 | println!("{}", s); // prints "hello world";
119 | ```
120 | 
121 | Beware of the bikeshed!
122 | 
123 | ---
124 | class: middle, left
125 | 
126 | # `String`s and capacity
127 | 
128 | While `&str`s are a pointer and a length, `String`s need to manage the memory they own,
129 | and therefore are *three* `usize`s in size: a pointer, a length, and a capacity. This lets
130 | a `String` request one big chunk of memory, so it doesn't need to allocate every time
131 | it's modified.
132 | 
133 | ```rust
134 | let mut s = String::from("hi");
135 | 
136 | // prints 2 - 2
137 | println!("{} - {}", s.len(), s.capacity());
138 | 
139 | s.push('!');
140 | 
141 | // prints 3 - 4; the capacity doubled!
142 | println!("{} - {}", s.len(), s.capacity());
143 | 
144 | s.push('!');
145 | 
146 | // prints 4 - 4; no need to expand this time
147 | println!("{} - {}", s.len(), s.capacity());
148 | ```
149 | 
150 | ---
151 | class: middle, left
152 | 
153 | # `Deref` and strings
154 | 
155 | `String` implements `Deref<Target=str>`, which means that you can pass a `&String` to
156 | something expecting a `&str`, and it will Just Work:
157 | 
158 | ```rust
159 | fn takes_str(s: &str) {
160 |     // ...
161 | }
162 | 
163 | let s = String::from("hello");
164 | 
165 | takes_str(&s);
166 | ```
167 | 
168 | Just throw an `&` on it!
169 | 
170 | ---
171 | class: middle, left
172 | 
173 | ## Accepting strings as a parameter
174 | 
175 | Given the `Deref` impl, you should generally accept `&str`s as arguments, so that
176 | your users can use `&str`s and `String`s both. However, if you want to accept even
177 | more types, and don't mind a complex type signature, you can use `AsRef`:
178 | 
179 | ```rust
180 | fn complicated<T>(s: T)
181 | where
182 |     T: AsRef<str>,
183 | {
184 |     let s = s.as_ref(); // s is a &str
185 | }
186 | 
187 | let s = "hello";
188 | complicated(s);
189 | 
190 | let s = String::from("hello");
191 | complicated(s); // no need for the &
192 | ```
193 | 
194 | But this tradeoff isn't worth it most of the time.
195 | 
196 | ---
197 | class: middle, left
198 | 
199 | # You can't index strings
200 | 
201 | Thanks to UTF-8 being variable-length, and the assumption that `[]` is always `O(1)`,
202 | you can't use `[]` to access the nth character of a string or anything like that:
203 | 
204 | ```rust
205 | let s = "hi";
206 | 
207 | s[1]; // in some langauges, this is 'i'
208 | ```
209 | 
210 | ```text
211 | error[E0277]: the trait bound `str: std::ops::Index<{integer}>` is not satisfied
212 |  --> src/main.rs:4:1
213 |   |
214 | 4 | s[0];
215 |   | ^^^^ the type `str` cannot be indexed by `{integer}`
216 | ```
217 | 
218 | You gotta decide if you want the nth byte, unicode scalar value, or grapheme cluster,
219 | and then use the API for the correct one.
220 | 
221 | > Note: Grapheme cluster support isn't really in the standard library; check out
222 | > the [`unicode-segmentation` crate](https://crates.io/crates/unicode-segmentation).
223 | 
224 | ---
225 | class: middle, left
226 | 
227 | # Strings and `+`
228 | 
229 | Since `&str`s are immutable, and don't own their memory, you can't add two of
230 | them with `+`:
231 | 
232 | ```rust
233 | let x = "hey " + "there";
234 | ```
235 | 
236 | ```text
237 | error[E0369]: binary operation `+` cannot be applied to type `&str`
238 | ```
239 | 
240 | It will work if the left hand side is a `String`; as then `+` takes
241 | ownership, adds the right hand side to it, and then gives ownership back.
242 | This can get tedious, especially if you're trying to chain `+`. Consider
243 | `format!` instead:
244 | 
245 | ```rust
246 | let x = format!("{}{}{}", 1, 2, 3);
247 | ```
248 | 
249 | As a bonus, note that these numbers aren't strings; you don't need to stringify them first.
250 |

251 | 253 | 256 | 257 | 258 | 259 | -------------------------------------------------------------------------------- /styles.css: -------------------------------------------------------------------------------- 1 | @import url('https://fonts.googleapis.com/css?family=Fira+Sans'); 2 | @import url('https://fonts.googleapis.com/css?family=Source+Code+Pro'); 3 | 4 | body { 5 | font-family: 'Fira Sans'; 6 | } 7 | 8 | .remark-code, .remark-inline-code { 9 | font-family: 'Source Code Pro'; 10 | } 11 | 12 | blockquote { 13 | background: #f9f9f9; 14 | border-left: 10px solid #ccc; 15 | margin: 1.5em 10px; 16 | padding: 0.5em 10px; 17 | } 18 | 19 | blockquote:before { 20 | color: #ccc; 21 | font-size: 4em; 22 | line-height: 0.1em; 23 | margin-right: 0.25em; 24 | vertical-align: -0.4em; 25 | } 26 | 27 | blockquote p { 28 | display: inline; 29 | } 30 | 31 | table { 32 | border: solid 1px #333; 33 | border-spacing: 0; 34 | border-collapse: collapse; 35 | text-align: center; 36 | } 37 | 38 | table thead th { 39 | background-color: #ccc; 40 | border: solid 1px #ccc; 41 | color: #333; 42 | padding: 10px; 43 | } 44 | 45 | table tbody td { 46 | border: solid 1px #ccc; 47 | color: #333; 48 | padding: 10px; 49 | } -------------------------------------------------------------------------------- /template.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Rust in ten slides 5 | 6 | 7 | 8 | 9 | 64 | 66 | 69 | 70 | 71 | 72 | --------------------------------------------------------------------------------