React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go

Rust SME Cookbook

Perguntas frequentes

Seções

Linguagem e Ownership

A Filosofia de Design do Rust Noções Básicas de Rust Variáveis, Mutabilidade e Shadowing Tipos Escalares e Compostos Funções & Expressões Fluxo de Controle Preview de Propriedade Referências e Slices O Sistema de Tipos e Inferência Formatação e Impressão Boas Práticas Fundamentais de Rust

O Modelo de Propriedade do Rust Noções Básicas de Propriedade Semântica de Move e Cópia Empréstimos & Referências O Verificador de Empréstimos Lifetimes Explained Anotações de Tempo de Vida Elisão de Lifetimes Non-Lexical Lifetimes & Reborrows 'static & Bounds Combatendo o Verificador de Empréstimos Boas Práticas de Propriedade

Modelando Dados com Structs e Enums Noções Básicas de Structs Métodos & Funções Associadas Enums Pattern Matching with match if let, let else & while let Option & Result como Enums Destructuring Derivando Traits Enums para Máquinas de Estado Boas Práticas de Structs & Enums

O Sistema de Traits do Rust como Design de Interface Noções Básicas de Traits Métodos Padrão e Supertraits Genéricos Trait Bounds Trait Objects e Despacho Dinâmico Dispatch Estático vs. Dinâmico Tipos Associados e Constantes Sobrecarga de Operadores Impls Blanket & Condicionais Common Standard Traits Boas Práticas de Traits & Generics

A Filosofia de Tratamento de Erros do Rust Noções Básicas de Tratamento de Erros O Operador ?panic! vs Erros Recuperáveis Tipos de Erro Personalizados thiserror anyhow Contexto e Backtraces de Erro Combinadores de Option Iteradores Falíveis e collect() <Result>Boas Práticas de Tratamento de Erros

O Modelo de Iterador em Rust Noções Básicas de Coleções Vec & Slices HashMap & BTreeMap VecDeque, BinaryHeap & LinkedList O Trait Iterator Adaptadores de Iterador Consumindo Iteradores API Entry & Atualizações In-Place IntoIterator & Owned vs Borrowed Boas Práticas para Coleções & Iteradores

Closures e os Traits Fn do Rust Noções Básicas de Closures Fn, FnMut & FnOnce move Closures Retornando Closures Funções de Ordem Superior Padrões de Iterador + Closure Ponteiros de Função vs. Closures Melhores Práticas de Closures

Ponteiros Inteligentes como Extensões de Propriedade Noções Básicas de Ponteiros Inteligentes Box<T>Rc & Arc RefCell & Cell Rc<RefCell<T>> & Arc<Mutex<T>>Referências Fracas Cow (Clone-on-Write)Deref & Deref Coercion Ponteiros Inteligentes Personalizados Boas Práticas de Ponteiros Inteligentes

Strings, UTF-8 e Texto em Rust Noções Básicas de Strings UTF-8 e Indexação Manipulação de Strings Parsing & Conversão Formatação Chars, Bytes & Graphemes Regex OsString, Path & CStr Boas Práticas de Strings

Módulos e Sistema de Crates do Rust Noções Básicas de Módulos Visibilidade & Privacidade use & Paths Crates & Pacotes Workspaces Projetando uma API Pública Feature Flags Padrões de Estrutura de Projeto Módulos e Crates: Melhores Práticas

O Contrato de Rust `unsafe`Noções Básicas de `unsafe`Ponteiros Brutos O Modelo de Memória do Rust Trabalhando com MaybeUninit Abstrações Seguras sobre `unsafe`Tipos Seguros para FFI Comportamento Indefinido Miri & Sanitizers Boas Práticas de Rust Inseguro

Concorrência e Async

Concorrência sem Medo em Rust Noções Básicas de Concorrência Send & Sync Canais Mutex & RwLock Arc para Estado Compartilhado Atomics & Ordering Threads com Escopo Paralelismo de Dados com Rayon Deadlocks & Race Conditions Boas Práticas de Concorrência

O Modelo Async do Rust Noções Básicas de Async O Trait Future Executors & Runtimes Pinning & Unpin async fn em Traits Streams Combinando Futures Cancelamento e Timeouts Bloqueio em Async Melhores Práticas Assíncronas

O Modelo de Runtime do Tokio Noções Básicas de Tokio Tarefas & JoinHandles I/O Assíncrono Canais no Tokio select! & Concorrência Timers & Intervals Estado Compartilhado em Async Tracing & Instrumentation Graceful Shutdown Melhores Práticas do Tokio

Ferramentas, Qualidade e Craft

Como o Cargo Pensa Sobre Dependências e Builds Noções Básicas de Cargo Explicação do Cargo.toml Features & Optional Dependencies Perfis e Configurações de Build Workspaces Scripts de Build (build.rs)Gerenciamento de Dependências Subcomandos Úteis do Cargo Publicando no crates.io Boas Práticas do Cargo

O Modelo de Testes do Rust Noções Básicas de Testes Unit vs Integration Tests Doctests Organização de Testes Mocking & Test Doubles Testes Baseados em Propriedades Testes de Snapshot Benchmarking com Criterion Testando Código Assíncrono Cobertura & CI Boas Práticas de Testes

Ferramentas de Qualidade Integradas do Rust rustfmt Clippy Níveis e Atributos de Lint Configurando o Clippy Lints de Documentação Configuração de Pre-commit & Editor Linting em CI Melhores Práticas de Linting e Formatação

Raciocínio sobre Desempenho em Rust Noções Básicas de Desempenho Benchmarking & Profiling Entendendo Alocações Abstrações de Custo Zero Evitando Clones SIMD & Vetorização Ajuste de Release Layout de Memória e Cache Reduzindo o Tamanho do Binário Boas Práticas de Desempenho

Sistema de Macros do Rust Noções Básicas de Macros macro_rules!Visão Geral de Macros Procedurais Macros Derive Macros de Atributo Macros do Tipo Função syn & quote Depurando Macros Melhores Práticas de Macros

Padrões de Design em Rust Noções Básicas de Padrões Rust O Padrão Newtype Builder Pattern Padrão Typestate RAII & Drop Guards From/Into & TryFrom Traits de Extensão e Iterador Padrões de Mutabilidade Interna Padrões Anti-Comuns Boas Práticas de Padrões Rust

Um Modelo Mental para Rust Idiomático 50 Regras de Rust que Todo Especialista Deve Seguir Diretrizes de API Rust 30 Regras de `unsafe`30 Regras Assíncronas 30 Regras de Performance Regras de Tratamento de Erros Referência de Problema / Solução Decisões de Arquitetura Rust

Arquitetando Sistemas em Rust Checklist de Decisão de Arquitetura Workspace & Crate Boundaries Estratégia de Erro Abstração Baseada em Traits Modelagem de Domínio com Tipos Configuração e Design de Funcionalidades Decisões de Refatoração Checklist de Auditoria de Código Migrando de C/C++ para Rust Boas Práticas de Arquitetura

Diagnosing Rust Compiler and Runtime Errors Cenários de Erro do Verificador de Empréstimos Cenários de Incompatibilidade de Tempo de Vida Cenários de Move-After-Use Send/Sync & Erros de Thread Deadlocks e Bloqueios Assíncronos Cenários de Panic & Unwrap Estouro de Inteiro e Bugs Numéricos FFI & Bugs Inseguros Ferramentas de Depuração Depurando Snippets de Refatoração

Web, Rede e Dados

O Modelo de Backend Web em Rust Noções Básicas de Backends Web Axum Routing & Handlers Extractors & State Middleware & Tower Tratamento de Erros em Handlers Validação de Requisições Autenticação e Sessões WebSockets & SSE Actix-web Testando Serviços Web Melhores Práticas para Backends Web

Como Funciona o Modelo de Serialização do Serde Bases do Serde JSON com serde_json Outros Formatos Personalizando a Serialização Serialização (De)serialização Personalizada Enums & Tagging Desserialização Zero-Copy Tratamento de Erros e Validação Melhores Práticas do Serde

Conversando com Bancos de Dados em Rust Noções Básicas de Bancos de Dados sqlx Diesel SeaORM Migrations Connection Pooling Transações e Isolamento Redis e Chave-Valor Padrões de Query & N+1 Melhores Práticas para Bancos de Dados

A Pilha de Rede e HTTP do Rust Clientes HTTP (reqwest)hyper gRPC com tonic TLS com rustls Sockets de Baixo Nível WebSockets Retries, Timeouts & Backoff Melhores Práticas de Rede

O Modelo de Segurança de API em Rust Noções Básicas de Design de API GraphQL em Rust JWT e OAuth2 Password Hashing Gerenciamento de Segredos Criptografia (ring / RustCrypto)Validação de Entrada e Injeção Rate Limiting & Abuse Prevention Segurança da Cadeia de Suprimentos APIs e Melhores Práticas de Segurança

Sistemas, WASM e Interop

Construindo CLIs do Jeito Rust Noções Básicas de CLI clap Configuração & Ambiente Saída do Terminal TUIs com ratatui Relatório de Erros Shell Completions & Man Pages Empacotamento e Distribuição Boas Práticas de CLI

Rust como Linguagem de Sistemas Noções Básicas de Sistemas libc & Syscalls Interoperabilidade C com bindgen Expondo Rust para C (cbindgen)Trabalhando com Memória Bruta Sinais & Controle de Processos Construindo Bindings Seguros Código de Sistemas Multiplataforma Boas Práticas de Programação de Sistemas

Modelo do WebAssembly no Rust Noções Básicas de WebAssembly wasm-bindgen wasm-pack & Bundling DOM & Web APIs (web-sys)Frontend Frameworks (Leptos / Yew)WASI WASM Components & o Modelo de Componentes Performance & Tamanho Melhores Práticas de WebAssembly

Rust em Ambientes Embarcados e no_std Noções Básicas de Embarcados Programação no_std embedded-hal Periféricos de Microcontrolador Interrupts & Concurrency Memória em Embarcados Async on Embedded (Embassy)Depurando Firmware Boas Práticas Embarcadas

Incorporando e Sendo Incorporado: Interoperabilidade com Rust Noções Básicas de Interoperabilidade PyO3 maturin Expondo uma Biblioteca Rust para C/C++Node.js com napi-rs Incorporando Rust em Outros Runtimes Data Marshalling Melhores Práticas de Interoperabilidade

Aplicações e Domínios

Modelo de Dados de Alto Desempenho do Rust Noções Básicas de Dados Apache Arrow Polars DataFusion I/O CSV/Parquet Streaming & Large Data Construindo CLIs e Serviços de Dados Interoperabilidade com Python/pandas Melhores Práticas para Dados de Alto Desempenho

Machine Learning em Rust: O Cenário Noções Básicas de ML em Rust candle burn ONNX Runtime (ort)Tokenizers LLM Inference & Serving Embeddings & Busca Vetorial GPU e Aceleração Servindo Modelos com Axum Boas Práticas de ML em Rust

Rust em Blockchain e Criptografia Noções Básicas de Blockchain em Rust Programas Solana Substrate & ink!Criptografia Aplicada Carteiras e Gerenciamento de Chaves Consenso & P2P Zero-Knowledge & Criptografia Avançada Segurança e Auditoria Melhores Práticas de Blockchain

Modelos de Arquitetura de GUI em Rust Noções Básicas de GUI Tauri egui iced Estado & Arquitetura Integração Nativa Empacotamento e Distribuição Melhores Práticas de GUI

Arquitetura de Desenvolvimento de Jogos em Rust Noções Básicas de Desenvolvimento de Jogos Bevy Engine Assets & Scenes Entrada & Eventos Gráficos com wgpu Física & Áudio Loops e Sincronização de Jogos Performance para Jogos Melhores Práticas de Desenvolvimento de Jogos

Ecossistema, Ops e Equipe

Os Crates Principais do Ecossistema Rust serde tokio anyhow & thiserror tracing clap rayon reqwest & sqlx chrono & time itertools & rand once_cell / LazyLock & dashmap Melhores Práticas Essenciais de Crates

Enviando Binários Rust para Produção Noções Básicas de Implantação Compilação Cruzada Imagens Docker Mínimas musl & Linkagem Estática CI/CD para Rust Configuração e Segredos em Produção Observabilidade Release & Versioning Melhores Práticas de Implantação

Usando Habilidades de Agente para Desenvolvimento em Rust Axum Service Skill Skill de Async / Tokio Habilidade de Revisão de Unsafe Skill WASM Skill Embarcada Skill de Publicação de Crates Skill de Performance Skill de Tratamento de Erros Skill de Melhores Práticas em Rust

O Modelo Mental do Git para Equipes Rust Comandos Essenciais do Git Branching & Merging Checklist de Resolução de Conflitos de Merge Git Worktrees GitHub CLI Configuração de CI para Rust Configuração do Git Boas Práticas do Git

O Modelo de Linha de Comando do Linux para Desenvolvedores Rust Noções Essenciais de Sysadmin rustup e Gerenciamento de Toolchain Ferramentas de Build & Inspeção Busca & Regex Ferramentas CLI Baseadas em Rust Pipes & Processamento de Texto Gerenciamento de Processos e Recursos Melhores Práticas da CLI do Linux

Onboarding e Convenções de Equipe para Codebases Rust Checklist de Onboarding de Desenvolvedores Checklist de Configuração da Toolchain Orientação da Base de Código Convenções e Guia de Estilo Diretrizes de Revisão de Código Melhores Práticas de Equipe

Craft de Tech Lead

O Modelo Mental de Resposta a Incidentes para Serviços Rust Depuração em Produção Playbooks de Resposta a Incidentes Post-Mortems Sem Culpa & Análise de Causa Raiz (RCA)Modos Comuns de Falha em Produção Runbooks de Rollback & Recuperação Transformando Incidentes em Guardrails Saúde do Plantão

Práticas de Entrega Empresarial para Equipes Rust Gerenciamento de Releases Feature Flags & Progressive Delivery Estratégias de Rollback Métricas DORA Testes A/B e Experimentação Ambientes & Promoção de Configuração Melhores Práticas de Entrega

Fundamentos de Liderança Técnica Tomada de Decisão Técnica Architecture Decision Records (ADRs)Executando Revisões de Design Cultura de Revisão de Código Mentoria & Nivelamento Delegação e Compartilhamento de Contexto Lidando com Desacordos Técnicos Melhores Práticas de Liderança

Trabalhando com Produto e Stakeholders como Engenheiro Rust Requisitos para Especificações Técnicas Priorizando Plataforma e Débito Técnico Estimativa & Risco Contribuições para o Roadmap Comunicação com Stakeholders Fazendo o Processo Funcionar (Scrum/Kanban/SAFe)Melhores Práticas de Colaboração de Produto

Como Ler Estes Estudos de Caso Referência: Um Serviço Axum de Alto Rendimento Referência: Uma Ferramenta CLI Distribuída para Usuários Referência: Um Módulo WASM em Produção Antes/Depois: Reescrevendo um Componento C/C++ em Rust Antes/Depois: Reduzindo Alocações em um Caminho Crítico Benchmarks de Latência e Throughput Catálogo de Lições Aprendidas

Modelos de Governança para Codebases Rust Padrões de Codificação e Diretrizes de API Convenções de Documentação Diretrizes de Contribuição Governança de Dependências e Código `unsafe`Edição & Atualizações da Toolchain Spikes, PoCs & Adoção de Novos Crates Crescimento na Carreira: Sênior para Líder para Staff/Principal Melhores Práticas de Governança

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Termos

Recurso educacional independente e não oficial. Sem afiliação, endosso ou patrocínio dos proprietários ou responsáveis pelas marcas.

Buscar na documentação

Busque em todas as páginas da documentação

Rust SME/Tags/Rust

#Rust505 pages

Pages tagged Rust across 50 sections.

API e Segurança

API Design Basics APIs & Security Best Practices Cryptography (ring / RustCrypto)GraphQL in Rust Input Validation & Injection JWT & OAuth2 Password Hashing Rate Limiting & Abuse Prevention Secrets Management Supply-Chain Security The API Security Model in Rust

Arquitetura e Design

Architecting Rust Systems Architecture Best Practices Architecture Decision Checklist Codebase Audit Checklist Configuration & Feature Design Domain Modeling with Types Error Strategy Migrating from C/C++ to Rust Refactoring Decisions Trait-Based Abstraction Workspace & Crate Boundaries

Async e Futures

Async Basics Async Best Practices async fn in Traits Blocking in Async Cancellation & Timeouts Combining Futures Executors & Runtimes Pinning & Unpin Streams The Future Trait The Rust Async Model

Applied Cryptography Blockchain Basics in Rust Blockchain Best Practices Consensus & P2P Rust in Blockchain and Cryptography Security & Auditing Solana Programs Substrate & ink!Wallets & Key Management Zero-Knowledge & Advanced Crypto

Build Scripts (build.rs)Cargo Basics Cargo Best Practices Cargo.toml Explained Dependency Management Features & Optional Dependencies How Cargo Thinks About Dependencies and Builds Profiles & Build Settings Publishing to crates.io Useful Cargo Subcommands Workspaces

Estudos de Caso

Before/After: Cutting Allocations on a Hot Path Before/After: Rewriting a C/C++ Component in Rust How to Read These Case Studies Latency & Throughput Benchmarks Lessons-Learned Catalog Reference: A CLI Tool Shipped to Users Reference: A High-Throughput Axum Service Reference: A WASM Module in Production

Ferramentas CLI

Building CLIs the Rust Way clap CLI Basics CLI Best Practices Configuration & Env Error Reporting Packaging & Distribution Shell Completions & Man Pages Terminal Output TUIs with ratatui

Closures and Rust's Fn Traits Closures Basics Closures Best Practices Fn, FnMut & FnOnce Function Pointers vs Closures Higher-Order Functions Iterator + Closure Patterns move Closures Returning Closures

Collections & Iterators Best Practices Collections Basics Consuming Iterators Entry API & In-Place Updates HashMap & BTreeMap IntoIterator & Owned vs Borrowed Iterator Adapters The Iterator Model in Rust The Iterator Trait Vec & Slices VecDeque, BinaryHeap & LinkedList

Arc for Shared State Atomics & Ordering Channels Concurrency Basics Concurrency Best Practices Data Parallelism with Rayon Deadlocks & Race Conditions Fearless Concurrency in Rust Mutex & RwLock Scoped Threads Send & Sync

Bancos de Dados

Connection Pooling Databases Basics Databases Best Practices Diesel Migrations Query Patterns & N+1 Redis & Key-Value SeaORM sqlx Talking to Databases from Rust Transactions & Isolation

Async Deadlocks & Blocking Borrow-Checker Error Scenarios Debugging Refactor Snippets Debugging Tools Diagnosing Rust Compiler and Runtime Errors FFI & Unsafe Bugs Integer Overflow & Numeric Bugs Lifetime Mismatch Scenarios Move-After-Use Scenarios Panic & Unwrap Scenarios Send/Sync & Thread Errors

CI/CD for Rust Configuration & Secrets in Prod Cross-Compilation Deployment Basics Deployment Best Practices Minimal Docker Images musl & Static Linking Observability Release & Versioning Shipping Rust Binaries to Production

egui GUI Basics GUI Best Practices iced Native Integration Packaging & Distribution Rust GUI Architecture Models State & Architecture Tauri

Async on Embedded (Embassy)Debugging Firmware Embedded Basics Embedded Best Practices embedded-hal Interrupts & Concurrency Memory in Embedded Microcontroller Peripherals no_std Programming Rust in Embedded and no_std Environments

Entrega Corporativa

A/B Testing & Experimentation Delivery Best Practices DORA Metrics Enterprise Delivery Practices for Rust Teams Environments & Config Promotion Feature Flags & Progressive Delivery Release Management Rollback Strategies

Tratamento de Erros

anyhow Custom Error Types Error Context & Backtraces Error Handling Basics Error Handling Best Practices Fallible Iterators & collect()Option Combinators panic! vs Recoverable Errors The ? Operator The Rust Error-Handling Philosophy thiserror

Crates Essenciais

anyhow & thiserror chrono & time clap Essential Crates Best Practices itertools & rand once_cell / LazyLock & dashmap rayon reqwest & sqlx serde The Rust Ecosystem's Core Crates tokio tracing

Desenvolvimento de Jogos

Assets & Scenes Bevy Engine Game Dev Basics Game Dev Best Practices Game Loops & Timing Graphics with wgpu Input & Events Performance for Games Physics & Audio Rust Game Development Architecture

Branching & Merging CI Config for Rust Essential Git Commands Git Best Practices Git Configuration Git Worktrees GitHub CLI Merge Conflict Resolution Checklist The Git Mental Model for Rust Teams

Career Growth: Senior to Lead to Staff/Principal Coding Standards & API Guidelines Contribution Guidelines Documentation Conventions Edition & Toolchain Upgrades Governance Best Practices Governance Models for Rust Codebases Spikes, PoCs & Adopting New Crates Unsafe & Dependency Governance

Dados de Alta Performance

Apache Arrow Building Data CLIs & Services CSV/Parquet I/O Data Basics DataFusion High-Performance Data Best Practices Interop with Python/pandas Polars Rust's High-Performance Data Model Streaming & Large Data

gRPC with tonic HTTP Clients (reqwest)hyper Low-Level Sockets Networking Best Practices Retries, Timeouts & Backoff Rust's Networking and HTTP Stack TLS with rustls WebSockets

Lint e Formatação

Clippy Configuring Clippy Documentation Lints Lint Levels & Attributes Linting & Formatting Best Practices Linting in CI Pre-commit & Editor Setup Rust's Built-In Quality Tooling rustfmt

Build & Inspect Tooling Linux CLI Best Practices Pipes & Text Processing Process & Resource Management Rust-Based CLI Tools rustup & Toolchain Management Search & Regex Sysadmin Essentials The Linux Command-Line Model for Rust Developers

Attribute Macros Debugging Macros Derive Macros Function-like Proc Macros macro_rules!Macros Basics Macros Best Practices Procedural Macros Overview Rust's Macro System syn & quote

burn candle Embeddings & Vector Search GPU & Acceleration LLM Inference & Serving Machine Learning in Rust: The Landscape ML in Rust Basics ML in Rust Best Practices ONNX Runtime (ort)Serving Models with Axum Tokenizers

Módulos e Crates

Crates & Packages Designing a Public API Feature Flags Modules & Crates Best Practices Modules Basics Project Structure Patterns Rust's Module and Crate System use & Paths Visibility & Privacy Workspaces

Data Marshalling Embedding and Being Embedded: Rust Interop Embedding Rust in Other Runtimes Exposing a Rust Library to C/C++Interop Basics Interop Best Practices maturin Node.js with napi-rs PyO3

'static & Bounds Borrowing & References Fighting the Borrow Checker Lifetime Annotations Lifetime Elision Lifetimes Explained Move Semantics & Copy Non-Lexical Lifetimes & Reborrows Ownership Basics Ownership Best Practices The Borrow Checker The Rust Ownership Model

Avoiding Clones Benchmarking & Profiling Memory Layout & Cache Performance Basics Performance Best Practices Reasoning About Performance in Rust Reducing Binary Size Release Tuning SIMD & Vectorization Understanding Allocations Zero-Cost Abstractions

Produto e Stakeholders

Estimation & Risk Making the Process Work (Scrum/Kanban/SAFe)Prioritizing Platform & Tech Debt Product Collaboration Best Practices Requirements to Technical Specs Roadmap Contributions Stakeholder Communication Working with Product and Stakeholders as a Rust Engineer

Control Flow Formatting & Printing Functions & Expressions Ownership Preview References & Slices Rust Basics Rust Fundamentals Best Practices Scalar & Compound Types The Rust Design Philosophy The Type System & Inference Variables, Mutability & Shadowing

Builder Pattern Common Anti-Patterns From/Into & TryFrom Interior Mutability Patterns Iterator & Extension Traits RAII & Drop Guards Rust Design Patterns Rust Patterns Basics Rust Patterns Best Practices The Newtype Pattern Typestate Pattern

30 Async Rules 30 Performance Rules 30 Unsafe Rules 50 Rust Rules Every Specialist Should Follow A Mental Model for Idiomatic Rust Error-Handling Rules Problem / Solution Reference Rust API Guidelines Rust Architecture Decisions

Custom (De)serialization Customizing Serialization Enums & Tagging Error Handling & Validation How Serde's Serialization Model Works JSON with serde_json Other Formats serde Basics serde Best Practices Zero-Copy Deserialization

Async / Tokio Skill Axum Service Skill Crate Publishing Skill Embedded Skill Error-Handling Skill Performance Skill Rust Best-Practices Skill Unsafe Review Skill Using Agent Skills for Rust Development WASM Skill

Box<T>Cow (Clone-on-Write)Custom Smart Pointers Deref & Deref Coercion Rc & Arc Rc<RefCell<T>> & Arc<Mutex<T>>RefCell & Cell Smart Pointers as Extensions of Ownership Smart Pointers Basics Smart Pointers Best Practices Weak References

Strings e Texto

Chars, Bytes & Graphemes Formatting OsString, Path & CStr Parsing & Conversion Regex String Manipulation Strings Basics Strings Best Practices Strings, UTF-8, and Text in Rust UTF-8 & Indexing

Structs e Enums

Deriving Traits Destructuring Enums Enums for State Machines if let, let else & while let Methods & Associated Functions Modeling Data with Structs and Enums Option & Result as Enums Pattern Matching with match Structs & Enums Best Practices Structs Basics

Building Sound Bindings C Interop with bindgen Cross-Platform Systems Code Exposing Rust to C (cbindgen)libc & Syscalls Rust as a Systems Language Signals & Process Control Systems Basics Systems Programming Best Practices Working with Raw Memory

Equipe e Onboarding

Code Review Guidelines Codebase Orientation Conventions & Style Guide Onboarding and Team Conventions for Rust Codebases Onboarding Devs Checklist Team Best Practices Toolchain Setup Checklist

Liderança Técnica

Architecture Decision Records (ADRs)Code Review Culture Delegation & Spreading Context Handling Technical Disagreements Leadership Best Practices Mentoring & Leveling Running Design Reviews Technical Decision-Making Technical Leadership Fundamentals

Benchmarking with Criterion Coverage & CI Doctests Mocking & Test Doubles Property-Based Testing Snapshot Testing Test Organization Testing Async Code Testing Basics Testing Best Practices The Rust Testing Model Unit vs Integration Tests

Async I/O Channels in Tokio Graceful Shutdown select! & Concurrency Shared State in Async Tasks & JoinHandles Timers & Intervals Tokio Basics Tokio Best Practices Tokio's Runtime Model Tracing & Instrumentation

Traits e Generics

Associated Types & Constants Blanket & Conditional Impls Common Standard Traits Default Methods & Supertraits Generics Operator Overloading Rust's Trait System as Interface Design Static vs Dynamic Dispatch Trait Bounds Trait Objects & Dynamic Dispatch Traits & Generics Best Practices Traits Basics

Resposta a Incidentes

Blameless Post-Mortems & RCA Common Production Failure Modes Incident Response Playbooks On-Call Health Production Debugging Rollback & Recovery Runbooks The Incident Response Mental Model for Rust Services Turning Incidents into Guardrails

FFI-Safe Types Miri & Sanitizers Raw Pointers Sound Abstractions over Unsafe The Rust Memory Model The Unsafe Rust Contract Undefined Behavior Unsafe Basics Unsafe Rust Best Practices Working with MaybeUninit

Actix-web Authentication & Sessions Axum Routing & Handlers Error Handling in Handlers Extractors & State Middleware & Tower Request Validation Testing Web Services The Rust Web Backend Model Web Backends Basics Web Backends Best Practices WebSockets & SSE

DOM & Web APIs (web-sys)Frontend Frameworks (Leptos / Yew)Performance & Size Rust's WebAssembly Model WASI WASM Components & the Component Model wasm-bindgen wasm-pack & Bundling WebAssembly Basics WebAssembly Best Practices

Related tags

List Explainer Advanced Best Practices Basics Performance Async Ownership