diff --git a/porque-rust.html b/porque-rust.html
index c1638b3..8a327d8 100644
--- a/porque-rust.html
+++ b/porque-rust.html
@@ -80,6 +80,12 @@
Porque Você DEVE Aprender Rust
+
+
+ Eu ia falar do porque o pessoal deveria aprender Rust,
+ mas acho que faz mais sentido dizer que o pessoal TEM
+ QUE aprender Rust.
+
@@ -108,6 +114,14 @@
Versão atual: 1.35
+
+
+ Parte burocrática da apresentação.
+
+ PS: Pode ser que, quando você essa apresentação, 1.35
+ não seja mais a versão atual; a cada 6 semanas, sai uma
+ nova versão do compilador.
+
@@ -117,7 +131,6 @@
-
Basic
(com números e estruturado)
@@ -138,10 +151,27 @@
, Scala
, Rust.
+
+
+ Um porque de história sobre esse que lhes apresenta
+ a linguagem:
+
+ Eu já trabalhei com todas essas linguagens. Fora
+ essas, eu ainda sei ler
+
+ - Perl
+ - Ruby
+ - Haskell
+
+
+
+ Alerta: Tudo aqui é a minha opinião sobre Rust e o
+ contexto geral de linguagens de programação.
+
@@ -153,6 +183,18 @@
-- Alan Perlis, "ALGOL"
+
+
+ Apesar de ter todas essas linguagens, eu ainda
+ preciso passar essa frase do Perlis, porque
+ realmente Rust mudou a forma como eu penso em
+ outras linguagens.
+
+ Apesar do forte do Rust ser a proteção de memória,
+ eu posso oficialmente dizer que agora eu entendo
+ generics muito melhor por causa da forma como o
+ Rust trabalha.
+
@@ -220,10 +262,25 @@
+
+
+ Honestamente, se surgir uma nova linguagem que
+ tenha mais proteções de memória, com performance
+ ainda melhor que C mas eu tiver que escrever uma
+ lista encadeada mais uma vez, eu destruo todas as
+ coisas tecnológicas ao meu redor...
+
+
+
+ E vou plantar batata.
+
+ ... porque aprendemos absolutamente NADA sobre
+ desenvolvimento.
+
@@ -240,6 +297,22 @@ fn main() {
println!("{}", a);
}
+
+
+ Primeiro contato com Rust: assim como C, tem uma
+ função `main`, que pode retornar um inteiro; para
+ atribuir variáveis, usa-se `let`.
+
+ Uma coisa: Rust é "strong and statically typed", o
+ que sigifnica que a linguagem tem tipos, mas por
+ padrão o compilador tenta inferir o tipo.
+
+ Uma outra forma de escrever o let seria:
+
+ ```
+ let a: u8 = 2;
+ ```
+
@@ -269,6 +342,11 @@ fn main() {
4 | a = 3;
| ^^^^^ cannot assign twice to immutable variable
+
+
+ ... mas se tu olhar com calma, tu vai ver que não só o
+ compilador disse, claramente, o que era o problema...
+
@@ -281,10 +359,21 @@ fn main() {
4 | a = 3;
| ^^^^^ cannot assign twice to immutable variable
+
+
+ ... como também vai dizer como resolver o problema.
+
+
+
+ Ou seja, o compilador não só vai lá e diz: ERRADO!
+
+ ... ele ainda dá uma dica de como resolver esse
+ problema.
+
diff --git a/quick-rust.html b/quick-rust.html
new file mode 100644
index 0000000..b0348a4
--- /dev/null
+++ b/quick-rust.html
@@ -0,0 +1,713 @@
+
+
+
+
+
+ Rápida Introdução ao Rust
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Rápida Introdução ao Rust
+
+
+
+
+
+
+
+
+
+
+
+
+
+ História
+
+
+ Criada em 2006 por Graydon Hoare.
+ Patrocinada pela Mozilla em 2009.
+ Versão 1.0 em 2015.
+ Versão atual: 1.35
+ Objetivo: Criar uma linguagem rápida mas com seguraça de memória.
+
+
+
+
+ Parte burocrática da apresentação.
+
+ PS: Pode ser que, quando você essa apresentação, 1.35
+ não seja mais a versão atual; a cada 6 semanas, sai uma
+ nova versão do compilador.
+
+
+
+
+
+
+ História
+
+
+
+
+ Basic
+ (com números e estruturado)
+ , dBase III Plus
+ , Clipper
+ , Pascal
+ , Cobol
+ , Delphi (ObjectPascal)
+ , C
+ , C++
+ , ActionScript (Flash)
+ , PHP
+ , JavaScript
+ , Python
+ , Objective-C
+ , Clojure
+ , Java
+ , Scala
+ , Rust.
+
+
+
+ Um porque de história sobre esse que lhes apresenta
+ a linguagem:
+
+ Eu já trabalhei com todas essas linguagens. Fora
+ essas, eu ainda sei ler
+
+ - Perl
+ - Ruby
+ - Haskell
+
+
+
+
+
+
+
+ Alerta: Tudo aqui é a minha opinião sobre Rust e o
+ contexto geral de linguagens de programação.
+
+
+
+
+
+ A language that doesn't affect the way you think
+ about programming, is not worth knowing.
+
+
+
+ -- Alan Perlis, "ALGOL"
+
+
+
+ Apesar de ter todas essas linguagens, eu ainda
+ preciso passar essa frase do Perlis, porque
+ realmente Rust mudou a forma como eu penso em
+ outras linguagens.
+
+ Apesar do forte do Rust ser a proteção de memória,
+ eu posso oficialmente dizer que agora eu entendo
+ generics muito melhor por causa da forma como o
+ Rust trabalha.
+
+
+
+
+
+
+ Meu Primeiro Rust
+
+
+fn main() {
+ println!("Hello, world!");
+}
+
+
+
+ Esse é um exemplo básico de como é um código Rust:
+
+ 1. A função de entrada no sistema é a main()
+ 2. Funções são definidas com `fn`.
+ 3. A linguagem usa chaves.
+ 4. A exclamação indica que `println` é uma macro (e que,
+ por de trás dos panos, vai ser gerado mais código).
+ 5. Linhas terminam com ponto e vírgula
+
+
+
+
+ Meu Primeiro Rust
+
+ Tempo para gerar esse código:
+
+ 0 segundos
+
+
+
+ Meu Primeiro Rust
+
+ cargo init
+
+
+ Apesar do compilar do rust ser o `rustc`, a linguagem vem
+ com o seu sistema de manutenção de projetos, chamado cargo.
+
+
+
+
+
+
+
+
+ "Cargo is the Rust package manager"
+
+
+ "Cargo downloads your Rust package’s dependencies,
+ compiles your packages, makes distributable
+ packages, and uploads them to crates.io, the Rust
+ community’s package registry."
+
+
+
+ Além de tudo que está indicado na descrição do cargo,
+ ele também interage fortemente com o `rustc` para
+ resolução de dependências duplicadas.
+
+ Por exemplo, no caso do meu primeiro estar usando
+ a biblioteca `log` versão 2.0, mas uma das dependências
+ precisar a `log` 1.2, Cargo e Rustc conversam para manter
+ as duas versões, usando "name mangling" para que
+ funções com mesmo nome mas formato diferente
+ possam estar no mesmo binário.
+
+ E sim, há "tree shaking" para a remoção de funções
+ não utilizadas.
+
+
+
+
+
+
+ Mas De Volta Ao Rust
+
+
+fn main() {
+ let a:u8 = 2;
+ println!("{}", a);
+}
+
+
+
+
+ Rust é uma linguagem fortemente e estaticamente tipada.
+ Para definir uma variável, inicia-se com `let`, nome
+ da variável, `:`, o tipo da variável (u8 = unsigned 8 bits),
+ `=` e o valor.
+
+
+
+ Mas De Volta Ao Rust
+
+
+fn main() {
+ let a = 2u8;
+ println!("{}", a);
+}
+
+
+
+
+ Uma coisa que é possível fazer é definir que o valor tem
+ uma determinada precisão e, com isso, deixar o tipo de
+ fora da definição da variável, e o compilador irá inferir
+ o tipo.
+
+
+
+ Mas De Volta Ao Rust
+
+
+fn main() {
+ let a = 2;
+ println!("{}", a);
+}
+
+
+
+
+ Ou pode-se deixar sem qualquer definição e o compilador
+ irá encontrar o melhor tipo que "caiba" o valor e seja
+ eficiente para a máquina destino.
+
+
+
+ Mas De Volta ao Rust
+
+
+fn factorial(i: u64) -> u64 {
+ match i {
+ 0 => 1,
+ n => n * factorial(n-1)
+ }
+}
+
+
+
+
+ Um pouco mais complicado, mas um fatorial:
+ A função (`fn`) recebe uma variável `i` que
+ é um unsigned de 64 bits (funções é o único
+ lugar onde inferência de tipos não ocorre)
+ e retorna um unsigned de 64 bits.
+
+ `match` faz pattern matching com o valor de `i`:
+ se for 0, a expressão do match fica com o valor `1`;
+ qualquer outro valor entra na segunda ponta como
+ `n`, e a expressão termina com esse valor multiplicado
+ pelo fatorial dele menos 1.
+
+
+
+ Mas De Volta ao Rust
+
+
+fn is_pred(i: u64) -> Bool {
+ if i % 2 == 0 {
+ True
+ } else {
+ False
+ }
+}
+
+
+
+ Um pouco parecido com Scala, para Rust o resultado
+ de uma função é a expressão final. Sim, ele tem
+ suporte a `return`, mas esse somente é usando no
+ caso de haver uma interrupção do fluxo de processamento
+ (por exemplo, guardians).
+
+
+
+
+ Mas De Volta ao Rust
+
+
+fn is_pred(i: u64) -> Bool {
+ i % 2 == 0
+}
+
+
+
+ Uma forma mais simples de escrever a função anterior.
+
+
+
+
+ Mas De Volta ao Rust
+
+
+enum IPAddr {
+ IPV4,
+ IPV6
+}
+
+
+
+ Rust tem enums como toda boa linguagem.
+
+
+
+
+ Mas De Volta ao Rust
+
+
+enum IPAddr {
+ IPV4(String),
+ IPV6(String)
+}
+
+
+
+
+ Mas De Volta ao Rust
+
+
+let home = IpAddr::V4(String::from("127.0.0.1");
+
+match home {
+ V4(ipv4_address) => println!("IPv4 addr: {}", ipv4_address),
+ V6(ipv6_address) => println!("Ipv6 addr: {}", ipv6_address),
+}
+
+
+
+
+
+
+ E Aquela "Segurança de Memória"?
+
+
+
+ 1. No Null Pointers
+
+
+match may_not_exist(value: Option<String>) {
+ match value {
+ Some(the_string) => println!("I got a string! {}", the_string),
+ None => println!("I got nothing")
+ }
+}
+
+
+
+ Para evitar null pointers, Rust usa a "habilidade"
+ ter enums com valores dentro com um enum chamado
+ "Option"; Option tem dois valores: Some, com o
+ valor dentro ou None, que não tem valor algum.
+
+
+
+
+ 2. No Shared Memory
+
+
+fn main() {
+ let a = String::from("A reference to a string in the code section copied to the stack");
+ let b = a;
+ println!("The string is: {}", a);
+}
+
+
+
+
+
+
+
+ É mais ou menos isso que Rust "pensa" internamente
+ quando vê uma variável: uma posição de memória, de
+ um tamanho já definido, de um tipo definido.
+
+ E essa posição de memória *pertence* apenas à
+ variável indicada.
+
+
+
+
+ 2. No Shared Memory
+
+
+fn main() {
+ let a = String::from("A reference to a string in the code section copied to the stack");
+ let b = &a;
+ println!("The string is: {}", a);
+}
+
+
+
+
+
+
+
+
+ presente := Presente { ... }
+canal <- presente
+
+
+
+ Num exemplo em Go, criamos uma estrutura e passamos
+ essa estrutura para outra thread através de um
+ canal.
+
+
+
+
+ presente := Presente { ... }
+canal <- presente
+presente.abrir()
+
+
+ ... e depois de passar o presente pra outra pessoa,
+ nós abrimos o presente.
+
+ Mas se estamos entregando um presente pra alguém,
+ como é que estamos abrindo o presente?
+
+ O borrow checker não permite esse tipo de coisa:
+ Ele irá barrar a função atual de continuar
+ utilizando a variável porque, afinal de contas,
+ agora a região de memória pertence à outra função
+ (uma função que está rodando em outra thread).
+
+
+
+
+ 3. Immutable variables by default
+
+
+fn main() {
+ let a = 3;
+ a = 5;
+}
+
+
+
+
+
+
+
+
+
+enum Result<T, E> {
+ Ok(T),
+ Err(E),
+}
+
+
+
+
+
+match File::create("something.txt") {
+ Ok(fp) => fp.write_all(b"Hello world"),
+ Err(err) => println!("Failure! {}", err),
+}
+
+
+
+
+
+
+ Compilador Chato mas Amigável
+
+
+
+
+fn main() {
+ let a = 2;
+ a = 3;
+ println!("{}", a);
+}
+
+
+
+
+
+3 | let a = 2;
+ | -
+ | |
+ | first assignment to `a`
+ | help: make this binding mutable: `mut a`
+4 | a = 3;
+ | ^^^^^ cannot assign twice to immutable variable
+
+
+
+ Se você tentar mudar um dado depois de criado, o
+ compilador Rust não vai deixar.
+
+
+
+
+
+3 | let a = 2;
+ | -
+ | |
+ | first assignment to `a`
+ | help: make this binding mutable: `mut a`
+4 | a = 3;
+ | ^^^^^ cannot assign twice to immutable variable
+
+
+
+ ... mas se tu olhar com calma, tu vai ver que não só o
+ compilador disse, claramente, o que era o problema...
+
+
+
+
+
+3 | let a = 2;
+ | -
+ | |
+ | first assignment to `a`
+ | help: make this binding mutable: `mut a`
+4 | a = 3;
+ | ^^^^^ cannot assign twice to immutable variable
+
+
+
+ ... como também vai dizer como resolver o problema.
+
+
+
+
+
+
+
+ Ou seja, o compilador não só vai lá e diz: ERRADO!
+
+ ... ele ainda dá uma dica de como resolver esse
+ problema.
+
+
+
+
+
+
+
+
+ A linguagem mais amada segundo o StackOverflow
+ Survey 2019
+
+
+
... pelo 4⁰ ano seguido.
+
+
+ O resultado do StackOverflow é sobre qual
+ linguagem os programadores realmente gostam de
+ programar (e quais eles tem pavor de usar).
+
+ Pessoalmente, depois de 30 anos programando,
+ quando começei a brincar com Rust, eu
+ finalmente me diverti enquanto programava.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+