O documento discute a linguagem de programação Rust. Apresenta como o autor conheceu e começou a usar Rust, destacando características como tipos seguros, gerenciamento de memória sem garbage collector e foco em segurança e desempenho. Também mostra exemplos básicos de código Rust e como criar um site simples e fazer requisições na web usando Rust.

1. (Nunca) Ouvi falar de Rust…
Mas como eu faço um site?
1 . 1

2. Olá pessoal!
2 . 1

3. Se você nunca ouviu falar de Rust…
2 . 2

4. Vou contar o que é Rust
2 . 3

5. Vou contar como eu conheci Rust
2 . 4

6. E alguns problemas que a linguagem me ajudou
a resolver
2 . 5

7. Mas se você já ouviu falar…
2 . 6

8. Vou mostrar alguns passos para
seguir aprendendo
2 . 7

9. Em 2015
3 . 1

10. Comecei a me envolver com o deploy das
aplicações do meu projeto
3 . 2

11. NPM + Python + Java + Closure Compiler + SCons
+ RVM…
3 . 3

12. Eu queria uma maneira simples de executar
aplicações
3 . 4

13. Objetivo
1 arquivo binário e cross-plataforma
3 . 5

14. As opções
4 . 1

15. "Pra escrever binário tem que ser C?"
4 . 2

16. Rust foi uma das opções na minha busca por
alternativas
4 . 3

17. "Mas o que é Rust?"
4 . 4

18. Rust
Rust é uma linguagem de programação de
sistemas que roda incrivelmente rápido, previne
falhas de segmentação, e garante segurança
entre threads.
5 . 1

19. "É uma linguagem bem moderna,
com foco em baixo nível"
5 . 2

20. Uma linguagem com várias
características funcionais:
Imutável por padrão
Não tem null ou unde ned
Pattern-matching
Closures
Structs e Enums
5 . 3

21. O que me chamou atenção para seguir
aprendendo:
Gera binários
Cross-plataforma
Preocupação em boas mensagens de erro
Focado em baixo nível
Mas com uma experiência de linguagem de alto nível
Linguagem com investimento da Mozilla
5 . 4

22. Todas essas características criam um ambiente
ideal para avançar com segurança
Mozilla Quantum
5 . 5

23. "Por que escolheram criar
uma linguagem de baixo
nível?"
Qantas falhas podem acontecer em um
programa de baixo nível?
6 . 1

24. Bu erOver ow, Segmentation Fault,
Use After Free…
6 . 2

25. Rust tem um sistema de tipos que previne
diversos erros de gerenciamento de memória,
em tempo de compilação
6 . 3

26. Gerenciamento de memória sem
Garbage Collector
6 . 4

27. Exemplo do Rust previne
apenas com o compilador
Vamos ver um pouco de Rust
7 . 1

28. Playground
fn main() {
let data = vec!();
println!("Data", data);
}
7 . 2

29. error: argument never used
--> src/main.rs:3:22
|
3 | println!("Data", data);
| ^^^^
error: aborting due to previous error
7 . 3

30. Playground
fn main() {
let data = vec!();
println!("Data {}", data);
}
7 . 4

31. error[E0277]: the trait bound
`std::vec::Vec<_>: std::fmt::Display` is not satisfied
--> src/main.rs:3:25
|
|println!("Data {}", data);
| ^^^^
`std::vec::Vec<_>` cannot be formatted with the default
formatter; try using `:?` instead if you are using
a format string
|
= help: the trait `std::fmt::Display`
is not implemented for `std::vec::Vec<_>`
= note: required by `std::fmt::Display::fmt`
error: aborting due to previous error
7 . 5

32. ^^^^ `std::vec::Vec<_>` cannot be formatted with the default
formatter; try using `:?` instead if you are using a
format string
7 . 6

33. Playground
fn main() {
let data = vec!();
println!("Data {:?}", data);
}
7 . 7

34. error[E0282]: type annotations needed
--> src/main.rs:2:16
|
2 | let data = vec!();
| ---- ^^^^^^ cannot infer type for `T`
| |
| consider giving `data` a type
|
error: aborting due to previous error
7 . 8

35. error[E0282]: type annotations needed
7 . 9

36. $ rustc --explain E0282
7 . 10

37. Playground
fn main() {
let data : Vec<char> = vec!();
println!("Data {:?}", data);
}
7 . 11

38. Data []
7 . 12

39. Imagine uma base de código bem
complexa
Código com threads
Processamento de imagens em paralelo
Coordenar muito acesso de I/O
7 . 13

40. Em resumo, imagine quão complexo um
navegador é por trás dos panos?
7 . 14

41. Existe algum problema neste código?
Playground
use std::thread;
use std::time::Duration;
fn main() {
let data = vec!();
thread::spawn(|| {
data.push('a');
});
thread::spawn(|| {
data.push('b');
});
thread::sleep(Duration::from_millis(50));
println!("Data {:?}", data);
}
7 . 15

42. Depois de vários ciclos de feedback na
compilação:
Não teremos acesso a memória já liberada
Teremos adicionado uma forma forma de evitar race
conditions
Nosso binário não terá esses problemas!
7 . 16

43. Playground
use std::thread;
use std::sync::{Arc, Mutex};
use std::time::Duration;
fn main() {
let data = Arc::new(Mutex::new(vec!()));
let writer = data.clone();
thread::spawn(move || {
let lock_result = writer.lock();
match lock_result {
Ok(mut locked_writer) => locked_writer.push('a'),
Err(_) => panic!("Could not acquire lock a"),
}
});
let writer = data.clone();
thread::spawn(move || {
let mut locked_writer = writer.lock().expect("Could not acquire lock b");
locked_writer.push('b');
});
thread::sleep(Duration::from_millis(50));
println!("Data {:?}", data);
}
7 . 17

44. Esse sistema de tipo traz novas
maneiras de expressar seu domínio
7 . 18

45. Que não conseguimos fazer em outras
linguagens mais conhecidas
7 . 19

46. Playground
#[derive(Debug)]
struct Pedido {
id: i32
}
fn novo_pedido() -> Pedido {
Pedido { id: 1 }
}
fn enviar_pedido(pedido: Pedido) {
// Código que envia o pedido
}
fn main() {
let pedido = novo_pedido();
enviar_pedido(pedido);
println!("Dados do pedido: {:?}", pedido);
}
7 . 20

47. error[E0382]: use of moved value: `pedido`
--> src/main.rs:18:39
|
16 | enviar_pedido(pedido);
| ------ value moved here
17 |
18 | println!("Dados do pedido: {:?}", pedido);
| ^^^^^^
value used here after move
7 . 21

48. Só podemos acessar o pedido antes de
enviarmos as informações nesse cenário
7 . 22

49. E isso é reforçado pelo compilador
7 . 23

50. Playground
#[derive(Debug)]
struct Pedido {
id: i32
}
fn novo_pedido() -> Pedido {
Pedido { id: 1 }
}
fn enviar_pedido(pedido: Pedido) {
// Código que envia o pedido
}
fn main() {
let pedido = novo_pedido();
println!("Dados do pedido: {:?}", pedido);
enviar_pedido(pedido);
}
7 . 24

51. Dados do pedido: Pedido { id: 1 }
7 . 25

52. Rust incentiva desde o inicio
do projeto
Tipos não conseguem veri car toda a lógica
testes
7 . 26

53. pub fn super_calculo(x: i32, y: i32) -> i32 {
x + y
}
#[test]
fn test_super_calculo() {
assert_eq!(3, super_calculo(1, 2));
}
7 . 27

54. $ cargo test
running 1 test
test test_super_calculo ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured;
0 filtered out
7 . 28

55. é vista como parte
importante do seu projeto
Documentação
7 . 29

56. Tentando evitar que exemplos quem
desatualizados
7 . 30

57. /// Realiza um grande cálculo que te deixará surpreso
/// # Examples
///
/// ```
/// use minha_lib::*;
///
/// assert_eq!(5, calculo_surpresa(1, 2));
/// ```
pub fn calculo_surpresa(x: i32, y: i32, z: i32) -> i32 {
x + y + z
}
7 . 31

58. Exemplos que aparecem na documentação são
executados durante os testes
$ cargo test
[...]
running 1 test
test src/lib.rs - calculo_surpresa (line 4) ... FAILED
failures:
---- src/lib.rs - calculo_surpresa (line 4) stdout ----
error[E0061]: this function takes 3 parameters
but 2 parameters were supplied
--> src/lib.rs:5:32
|
5 | assert_eq!(5, calculo_surpresa(1, 2));
| ^^^^ expected 3 parameters
7 . 32

59. Gerar a documentação do projeto é simples
$ cargo doc --open
7 . 33

60. 7 . 34

61. Uma linguagem de sistemas:
Tem mensagens de erros claras
Que se preocupa com documentação e testes
E traz todas essas aprendizagens de outras linguagens
É uma ótima evolução para todo o ecossistema
de baixo nível
7 . 35

62. E uma ótima opção para
construir plataformas de alto nível
7 . 36

63. Mas você não precisa se preocupar
com tudo isso agora
7 . 37

64. Essas foram exemplos de possibilidades e
potencial da linguagem
7 . 38

65. Você pode aprender aos poucos, na sua
velocidade
7 . 39

66. E começando com o que você já está
acostumado em outras linguagens
7 . 40

67. Quem já ouviu falar de Rust?
8 . 1

68. Ah, e esse é o mascote, Ferris
(E dá pra um pra você)costurar
8 . 2

69. Agora, como faço um site?
8 . 3

70. Vamos fazer um site?
0:00 / 0:20

71. 9 . 1

72. Um Site:
Leve
Fácil de deployar
Aproveitando todas as vantagens que eu já comentei
9 . 2

73. Primeiro passo: Instalando as
ferramentas
Siga as instruções no site do Rustup

74. 10 . 1

75. Esse é o gerenciador de versões do Rust
Vai instalar todas as ferramentas
Suporta Linux, Mac e Windows
Ajuda a manter tudo atualizado
10 . 2

76. No nal estará disponível:
rustup: o gerenciador de versões
cargo: o gerenciador de projetos e de dependências
rustc: o compilador
rustdoc: o gerador de documentação
rust-gdb e rust-lldb: debuggers
10 . 3

77. Criando nosso projeto
$ cargo new --bin meu-site-em-rust
11 . 1

78. $ cargo run
Compiling meu-site-em-rust v0.1.0
Finished dev [unoptimized + debuginfo] target(s) in 1.54 secs
Running `target/debug/meu-site-em-rust`
Hello, world!
11 . 2

79. Vamos criar uma primeira
página
Vamos criar um arquivo em src/index.html
com seguinte conteúdo
12 . 1

80. <!doctype html>
<html>
<head>
<meta charset=utf-8>
<title>Olá TDC POA 2017</title>
</head>
<body>
<h1>Olá mundo</h1>
<marquee>Olá TDC</marquee>
</body>
</html>
12 . 2

81. Adicionando um framework
web
Vamos usar o framework para nos ajudarNickel

82. 13 . 1

83. Adicione a dependência no arquivo Cargo.toml
[dependencies]
nickel = "0.10.0"
13 . 2

84. Alterando nosso arquivo
Agora vamos ver um pouco de Rust, aos poucos.
Vamos abrir o arquivo src/main.rs.
14 . 1

85. Primeiro, importamos e incluímos algumas
referências do framework web.
#[macro_use]
extern crate nickel;
use nickel::{Nickel, HttpRouter};
14 . 2

86. Incluímos todo o conteúdo do nosso arquivo
HTML em uma constante.
const INDEX: &str = include_str!("index.html");
14 . 3

87. Criamos um novo servidor Nickel.
let mut server = Nickel::new();
server.get("/", middleware!(INDEX));
14 . 4

88. Con guramos a porta a partir da variável de
ambiente PORT. Vamos usar a porta 3000 de
fallback.
let port = std::env::var("PORT").unwrap_or("3000".into());
let url = format!("0.0.0.0:{port}", port = port);
14 . 5

89. Iniciamos o nosso servidor, com uma mensagem
caso haja erros.
println!("On {}", url);
server.listen(url)
.expect("Não conseguimos iniciar o servidor");
14 . 6

90. No nal teremos isso:
#[macro_use]
extern crate nickel;
use nickel::{Nickel, HttpRouter};
const INDEX: &str = include_str!("index.html");
fn main() {
let mut server = Nickel::new();
server.get("/", middleware!(INDEX));
let port = std::env::var("PORT").unwrap_or("3000".into());
let url = format!("0.0.0.0:{port}", port = port);
println!("On {}", url);
server.listen(url)
.expect("Não conseguimos iniciar o servidor");
}
14 . 7

91. Agora podemos criar o nosso
executável
$ cargo build --release
15 . 1

92. E executar:
$ ./target/release/meu-site-em-rust
On 0.0.0.0:3000
Listening on http://0.0.0.0:3000
Ctrl-C to shutdown server
15 . 2

93. TA-DÁ!
15 . 3

94. Parabéns!
Você tem um site em Rust.

95. 16 . 1

96. E tudo em um só binário!
16 . 2

97. E tem demo no Heroku!
https://ouvi-falar-de-rust.herokuapp.com/
16 . 3

98. "Mas dá pra fazer mais
alguma coisa?"
17 . 1

99. Vamos fazer uma
chamada web
18 . 1

100. É tão fácil como outras linguagens, mesmo
sendo uma linguagem de sistemas
18 . 2

101. Vou seguir a receita disponível no
Rust Cookbooks
18 . 3

102. Criando mais um novo projeto
$ cargo new --bin minha-chamada-em-rust
18 . 4

103. $ cargo run
Compiling minha-chamada-em-rust v0.1.0
Finished dev [unoptimized + debuginfo] target(s) in 1.54 secs
Running `target/debug/minha-chamada-em-rust`
Hello, world!
18 . 5

104. Adicionando uma lib para chamadas
18 . 6

105. Já existem diversas bibliotecas disponíveis no
Crates.io
18 . 7

106. Vamos usar o nesse projetoReqwest
18 . 8

107. Adicione a dependência no arquivo Cargo.toml
[dependencies]
reqwest = "0.8.0"
18 . 9

108. Alterando nosso binário
Vamos importar a nossa biblioteca e algumas
funções de I/O
extern crate reqwest;
use std::io::Read;
18 . 10

109. E criar nossa função
fn main() {
let mut response = reqwest::get("https://httpbin.org/get")
.expect("Could not connect");
println!("Resposta: {:?}", response);
let mut content = String::new();
response.read_to_string(&mut content);
println!("Conteudo do site: {}", content);
}
18 . 11

110. TA-DÁ
Vamos executar!
$ cargo run
18 . 12

111. 18 . 13

112. Agora você tem um código para fazer chamadas
na internet!
binário
cross-plataforma
com baixo uso de memória
que não precisa de car instalando várias dependências
para usar
18 . 14

113. Bem similar a outras linguagens?
18 . 15

114. "Uma pergunta…"
19 . 1

115. É fácil aprender Rust?
Eu passei semanas batendo a cabeça em
conceitos que eram novos para mim.
19 . 2

116. Tenho um background mais alto nível
(Ruby/Java/JavaScript)
Tive que aprender sobre stack e referências
Os conceitos sobre lifetime e borrow demoraram pra
entrar na minha cabeça
19 . 3

117. Rust trouxe novos conceitos para minha caixa de
ferramentas.
E eu tenho me divertido muito!
19 . 4

118. A comunidade é muito aberta e me ajudou
bastante, e tem muito interesse em trazer
pessoas novas.
Muitas pessoas estão disponíveis para ajudar no
, no e até no .#rust-beginners fórum #rust-br
19 . 5

119. Existe um grande esforço em tornar todo o
ecossistema inclusivo, tanto a participação das
pessoas quanto material para todos os níveis.
19 . 6

120. Iniciativa para ensinar Rust para quem não é
bem representado na área de tecnologia
RustBridge
19 . 7

121. Com interesse de tornar a linguagem uma boa
primeira linguagem de programação
19 . 8

122. Todas as propostas de mudança da linguagem
seguem um processo de
Evolução colaborativa
RFC
19 . 9

123. Que agora requer que novas propostas tenham
e uma maneira clara para
ensinar a mudança
documentação
19 . 10

124. Como eu coloco meu site no Heroku?
Eu usei esse .buildpack
19 . 11

125. Só existe o Nickel para web?
Já existem vários frameworks, mas ainda é um
ecossistema em desenvolvimento.
19 . 12

126. Uma boa lista está disponível no site Are We
Web Yet?
19 . 13

127. Se você estiver buscando algo mais
experimental:
Con ra o , que usa uma sintaxe mais
sucinta…
Rocket
19 . 14

128. Mas depende de funcionalidades do compilador
ainda em desenvolvimento.
19 . 15

129. Preciso usar rustup?
É o método mais recomendado pela
comunidade
É a maneira mais fácil de manter tudo atualizado
Rust tem uma versão nova a cada 6 semanas
Fica mais fácil de acompanhar as novas funcionalidades
19 . 16

130. Rust está disponível nos gerenciadores de
pacotes dos sistemas operacionais também, mas
pode demorar um pouco mais para receber
atualizações.
19 . 17

131. Como conectar em um banco?
O pode ajudar nisso.Diesel
19 . 18

132. Já existem empresas usando Rust?
Sim. Inclusive o Firefox do seu computador já
tem partes em Rust.
Algumas empresas: Dropbox, Chef, Tilde, Sentry,
CoreOS, Mozilla e tem mais .na lista do site
19 . 19

133. Só dá pra usar Rust para a web?
Não, dá pra usar para muitos outros lugares!
19 . 20

134. (Se eu fosse falar todos os exemplos, seria uma
outra apresentação inteira)
19 . 21

135. Dois fortes* espaços para aplicar a linguagem:
Ferramentas de suporte (CLIs, build, processadores de
texto, etc)
Extensões de linguagens (Gems, npm, python extensions,
FFI)
*IMHO
19 . 22

136. , , , ,
, , ,
, , Sistemas Operacionais ,
, , …
Machine Learning Ruby Python Haskell
Node.js WebAssembly Container Network
Platform Embedded 123
Jogos cross-compilação CI
19 . 23

137. Espero que tenham gostado
de Rust
20 . 1

138. E se quiser seguir conhecendo
Tem um no site [EN]
é um ótimo canal para tirar dúvidas
rápidas
Existe o para falar em portugues
O grupo no Telegram
E em portugues
livro de graça
#rust-beginners
#rust-br
@rustlangbr
Meetups
Exercicios
grupo de estudo online
20 . 2

139. Se você se interessou por Rust, pode entrar em
contato comigo também, que eu quero te ajudar
com os próximos passos.
Bruno Tavares - @bltavares
20 . 3

140. Links
intorust(); screencasts
Podcast da Lambda 3 - Em portugues
https://github.com/bltavares/meu-site-em-rust
Imagens do Ferris
http://edunham.net/2016/04/11/plushie_rustacean_pattern.html
https://rustup.rs/
https://github.com/nickel-org/nickel.rs
https://ouvi-falar-de-rust.herokuapp.com/
https://riot.im/app/#/room/#mozilla_#rust-beginners:matrix.org
https://users.rust-lang.org/
https://riot.im/app/#/room/#mozilla_#rust-br:matrix.org
https://github.com/emk/heroku-buildpack-rust
http://www.arewewebyet.org/
https://rocket.rs/
https://diesel.rs/
https://www.rust-lang.org/en-US/friends.html
http://www.arewelearningyet.com/
https://usehelix.com/
https://github.com/mitsuhiko/snaek
https://github.com/mgattozzi/curryrs
https://www.neon-bindings.com/
https://hackernoon.com/compiling-rust-to-webassembly-guide-411066a69fde
https://blogs.oracle.com/developers/building-a-container-runtime-in-rust
https://tokio.rs/
https://github.com/rust-embedded
20 . 4