• No hay productos en el carrito.

Inicio / Cursos / Rust: The Complete Developer's Guide
Impartido por Stephen GriderPago único de $2,800 MXN · acceso por 12 meses

Rust: The Complete Developer's Guide

Become a Rust engineer. Understand ownership, lifetimes, traits, generics, and much more through practical projects

Certificado oficial emitido por la SEPA través del Gobierno del Estado de México
12 meses de acceso En línea · 55 h 11 unidades
Qué aprenderás

Lo que serás capaz de hacer

Welcome to the most comprehensive and hands-on course for learning Rust from the ground up! Rust is revolutionizing systems programming with its focus on memory safety, concurrency, and performance. But with its unique concepts and syntax, many find Rust challenging to learn . That's where this course comes in – providing you with a clear, structured path to Rust mastery. What sets this course apart? We focus on building a rock-solid foundation in Rust's core concepts. No fluff, no skipping steps – just pure, essential Rust knowledge that will set you up for success in any Rust project. Rust's most challenging concepts are covered: Rust's ownership model? Explained in great detail! Lifetimes and borrowing? Its here! Traits and generics? You'll use them to write flexible code This course is designed for developers who want to truly understand Rust, not just copy-paste code. Whether you're coming from Javascript, Python, or any other language, you'll find a welcoming introduction to Rust's unique paradigms. Rust has been voted the "most loved programming language" in the Stack Overflow Developer Survey for seven consecutive years. It's not just hype – major companies like Microsoft, Google, and Amazon are increasingly adopting Rust for critical systems. By mastering Rust, you're not just learning a language; you're future-proofing your career. Here's a (partial) list of what you'll learn: Dive deep into Rust's type system and how it ensures memory safety Master pattern matching and destructuring for elegant, expressive code Harness the power of Rust's error handling with Result and Option types Explore Rust's module system to organize and scale your projects Implement common data structures and algorithms the Rust way Use cargo to manage dependencies and build your projects with ease A solid grasp of Rust's syntax and core concepts The ability to write safe, efficient, and idiomatic Rust code Confidence to tackle real-world Rust projects and contribute to the ecosystem A deep and fundamental understanding of error handling The skills to optimize code for performance and memory usage And much more! How This Course Works: This isn't just another "follow along" coding course. We've structured the learning experience to ensure you truly internalize Rust's concepts: Concept Introduction: Clear, concise explanations of each Rust feature Live Coding: Watch as we implement concepts in real-time, explaining our thought process Challenges: Test your understanding with carefully crafted coding exercises Project Work: Apply your skills to build progressively complex projects Best Practices: Learn idiomatic Rust and industry-standard coding patterns This is the course I wish I had when I was learning Rust. A course that focuses on the hardest parts, gives clear explanations, and discusses the pros and cons of different design options. Sign up today and join me in mastering Rust!

  • Master Rust's unique ownership system and borrowing rules for efficient memory management
  • Understand and implement Rust's powerful enum types and pattern matching
  • Develop proficiency in creating and organizing Rust projects using modules
  • Learn to handle errors effectively using the Result type and various error-handling techniques
  • Gain expertise in working with Rust's iterator system for efficient data processing
  • Explore advanced lifetime concepts to manage complex memory relationships

Temario

UNIDAD 1 - Foundations of Rust: Setup and First Steps · 6 lecciones

UNIDAD 1 - Foundations of Rust: Setup and First Steps

  • IntroductionVideo · 1 min
  • Rust InstallationVideo · 2 min
  • Local Rust InstallLectura · 0 min
  • Creating and Running Rust ProjectsVideo · 3 min
  • Disabling Inlay Type HintsLectura · 0 min
  • Course ResourcesLectura · 0 min
UNIDAD 2 - Core Concepts: The Building Blocks of Rust · 12 lecciones

UNIDAD 2 - Core Concepts: The Building Blocks of Rust

  • Representing Data with StructsVideo · 9 min
  • Adding Functionality to StructsVideo · 6 min
  • Arrays vs VectorsVideo · 6 min
  • Mutable vs Immutable BindingsVideo · 5 min
  • Implementations and MethodsVideo · 8 min
  • Implicit ReturnsVideo · 4 min
  • Installing External CratesVideo · 6 min
  • Using Code from CratesVideo · 8 min
  • Shuffling a SliceVideo · 4 min
  • Splitting a VectorVideo · 11 min
  • Project ReviewVideo · 4 min
  • A Taste of RustCuestionario · 0 min
UNIDAD 3 - Ownership and Borrowing: Rust's Unique Memory System · 27 lecciones

UNIDAD 3 - Ownership and Borrowing: Rust's Unique Memory System

  • Project OverviewVideo · 3 min
  • Defining StructsVideo · 4 min
  • Adding Inherent ImplementationsVideo · 5 min
  • A Mysterious ErrorVideo · 4 min
  • Unexpected Value UpdatesVideo · 9 min
  • The Goal of Ownership and BorrowingVideo · 6 min
  • The Basics of OwnershipVideo · 6 min
  • Owning and Moving ValuesCuestionario · 0 min
  • Visualizing Ownership and MovesVideo · 12 min
  • More on Owning and MovingCuestionario · 0 min
  • Exercise OverviewVideo · 1 min
  • Exercise SolutionVideo · 2 min
  • Another Quick ExerciseVideo · 2 min
  • A Quick Exercise SolutionVideo · 4 min
  • Writing Useful Code with OwnershipVideo · 5 min
  • Working Around OwnershipCuestionario · 0 min
  • Introducing the Borrow SystemVideo · 4 min
  • Immutable ReferencesVideo · 9 min
  • Working with ReferencesCuestionario · 0 min
  • Exercise On ReferencesVideo · 1 min
  • References Exercise SolutionVideo · 2 min
  • Mutable ReferencesVideo · 8 min
  • Handling Mutable ReferencesCuestionario · 0 min
  • Exercise on Mutable RefsVideo · 1 min
  • Solution on Mutable RefsVideo · 6 min
  • Copy-able ValuesVideo · 4 min
  • Understanding Copies vs MovesCuestionario · 0 min
UNIDAD 4 - Lifetimes Explored: Understanding Memory Management · 7 lecciones

UNIDAD 4 - Lifetimes Explored: Understanding Memory Management

  • Basics of LifetimesVideo · 7 min
  • LifetimesCuestionario · 0 min
  • Deciding on Argument TypesVideo · 5 min
  • Back to the Bank ImplVideo · 2 min
  • Implementing Deposits and WithdrawalsVideo · 6 min
  • Accounts and Bank ImplementationVideo · 7 min
  • Project WrapupVideo · 2 min
UNIDAD 5 - Enums Unleashed: Pattern Matching and Options · 16 lecciones

UNIDAD 5 - Enums Unleashed: Pattern Matching and Options

  • Project OverviewVideo · 1 min
  • Defining EnumsVideo · 6 min
  • Declaring Enum ValuesVideo · 1 min
  • Adding Implementations to EnumsVideo · 8 min
  • Pattern Matching with EnumsVideo · 4 min
  • When to Use Structs vs EnumsVideo · 3 min
  • Adding Catalog ItemsVideo · 4 min
  • Unlabeled FieldsVideo · 6 min
  • EnumsCuestionario · 0 min
  • The Option EnumVideo · 6 min
  • Option From Another PerspectiveVideo · 13 min
  • Replacing Our Custom Enum with OptionVideo · 3 min
  • Other Ways of Handling OptionsVideo · 10 min
  • The Option EnumCuestionario · 0 min
  • Excercise OverviewVideo · 2 min
  • Exercise SolutionVideo · 3 min
UNIDAD 6 - Project Architecture: Mastering Modules in Rust · 3 lecciones

UNIDAD 6 - Project Architecture: Mastering Modules in Rust

  • Modules OverviewVideo · 6 min
  • Rules of ModulesVideo · 3 min
  • Refactoring with Multiple ModulesVideo · 8 min
UNIDAD 7 - Handling the Unexpected: Errors and Results · 22 lecciones

UNIDAD 7 - Handling the Unexpected: Errors and Results

  • Project OverviewVideo · 2 min
  • Reading a FileVideo · 2 min
  • The Result EnumVideo · 5 min
  • The Result Enum in ActionVideo · 7 min
  • Types of ErrorsVideo · 3 min
  • Matching on ResultsVideo · 3 min
  • Empty OK VariantsVideo · 8 min
  • Exercise Around the Result EnumVideo · 1 min
  • Exercise SolutionVideo · 3 min
  • Using a Result When Reading FilesVideo · 4 min
  • Tricky StringsVideo · 4 min
  • The Stack and HeapVideo · 5 min
  • Strings, String Refs, and String SlicesVideo · 6 min
  • When to Use Which StringVideo · 11 min
  • StringsCuestionario · 0 min
  • Finding Error LogsVideo · 8 min
  • Understanding the IssueVideo · 11 min
  • Fixing Errors Around String SlicesVideo · 5 min
  • Writing Data to a FileVideo · 4 min
  • Alternatives to Nested MatchesVideo · 7 min
  • The Try OperatorVideo · 10 min
  • When to Use Each TechniqueVideo · 7 min
UNIDAD 8 - Iterator Deep Dive: Efficient Data Processing · 19 lecciones

UNIDAD 8 - Iterator Deep Dive: Efficient Data Processing

  • Project OverviewVideo · 2 min
  • Basics of IteratorsVideo · 7 min
  • Using For Loops with IteratorsVideo · 5 min
  • Iterator ConsumersVideo · 5 min
  • Iterator AdaptorsVideo · 5 min
  • Vector SlicesVideo · 9 min
  • Reminder on Ownership and BorrowingVideo · 5 min
  • Iterators with Mutable RefsVideo · 5 min
  • Mutable Vector SlicesVideo · 1 min
  • Collecting Elements from an IteratorVideo · 6 min
  • How Collect WorksVideo · 9 min
  • Moving Ownership With Into_IterVideo · 7 min
  • Inner MapsVideo · 4 min
  • Reminder on LifetimesVideo · 7 min
  • Iterators WrapupVideo · 6 min
  • Collect ExcerciseVideo · 1 min
  • Exercise SolutionVideo · 1 min
  • The Filter MethodVideo · 1 min
  • Filter SolutionVideo · 1 min
UNIDAD 9 - Advanced Lifetimes: Mastering Rust's Memory Model · 7 lecciones

UNIDAD 9 - Advanced Lifetimes: Mastering Rust's Memory Model

  • Lifetime AnnotationsVideo · 3 min
  • A Missing AnnotationVideo · 5 min
  • A Review of Borrowing RulesVideo · 5 min
  • What Lifetime Annotation Are All AboutVideo · 6 min
  • Common Questions Around LifetimesVideo · 6 min
  • Lifetime ElisionVideo · 8 min
  • Common LifetimesVideo · 6 min
UNIDAD 10 - Generics and Traits: Writing Flexible, Reusable Code · 12 lecciones

UNIDAD 10 - Generics and Traits: Writing Flexible, Reusable Code

  • Project SetupVideo · 4 min
  • Issues with Number TypesVideo · 5 min
  • The Basics of GenericsVideo · 7 min
  • Trait BoundsVideo · 4 min
  • Multiple Generic TypesVideo · 2 min
  • Super Solve FlexibilityVideo · 2 min
  • App OverviewVideo · 4 min
  • Building the BasketVideo · 6 min
  • Generic StructsVideo · 5 min
  • More on Generic StructsVideo · 6 min
  • Implementing a traitVideo · 5 min
  • Generic Trait Bounds (Final Lecture)Video · 3 min
UNIDAD 11 - Bonus! · 1 lecciones

UNIDAD 11 - Bonus!

  • Bonus!Lectura · 0 min
Certificado oficial

Tu certificado lo emite la SEP, no solo una plataforma

Al demostrar la competencia recibes un certificado emitido por la Secretaría de Educación Pública a través del Gobierno del Estado de México: un documento oficial que puedes presentar con confianza ante cualquier empleador o institución.

Tu certificado con INEC

  • Lo emite la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México
  • Documento oficial con folio verificable en línea
  • Lo otorga la Universidad Tecnológica Fidel Velázquez

Otras plataformas en línea

  • Constancia privada emitida por la misma plataforma
  • Solo acredita horas cursadas o asistencia
  • Sin respaldo de una autoridad educativa
Cómo funciona

Tu itinerario, de la inscripción al certificado

  1. 1

    Inscripción con pago único

    Pagas $2,800 MXN una sola vez y entras de inmediato al curso.

  2. 2

    Estudias a tu ritmo

    11 unidades con videos, lecturas y actividades, disponibles 24/7 durante 12 meses.

  3. 3

    Cuestionarios por unidad

    11 cuestionarios para comprobar lo aprendido.

  4. 4

    Certificado

    Emitido por la SEP a través del Gobierno del Estado de México, con folio verificable.

Lo que obtienes

Un certificado oficial de la SEP

Muestra del certificado: Rust: The Complete Developer's Guide

Muestra · verificable por folio y QR

  • Emitido por la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México. No es una constancia privada: es un documento oficial, y ese respaldo marca la diferencia frente a otras plataformas en línea.
  • Contenido impartido por Stephen Grider.
  • Folio y QR verificables para compartirlo con quien te contrate.
Medios que necesitas
Equipo de cómputo Conexión estable a internet
Pago único

Empieza hoy, a tu ritmo

Un solo pago y acceso inmediato al curso completo durante 12 meses.

  • 11 unidades · 132 lecciones · 55 h
  • 12 meses de acceso
  • 11 cuestionarios de evaluación
  • Certificado emitido por la SEP (Gob. del Estado de México) con folio verificable
Pago único
$2,800MXN
Acceso por 12 meses
Inscribirme Hablar con un asesor
Preguntas frecuentes

Sobre tu inscripción

¿Cómo es el pago?

Un solo pago de $2,800 MXN. No hay mensualidades ni cargos recurrentes.

¿Cuánto tiempo tengo acceso?

12 meses desde tu inscripción, 24/7, para avanzar a tu ritmo.

¿Quién imparte el contenido?

El curso es impartido por Stephen Grider; INEC gestiona tu inscripción, evaluación y certificado.

¿Qué pasa cuando vence mi acceso?

Puedes renovar tu cuenta tú mismo desde la plataforma, sin trámites ni esperas.

Certificado emitido por la SEP a través del Gobierno del Estado de México · Rust: The Complete Developer's Guide

Inscribirme
  INEC es una Marca de SalesPartners Ciudad de México S de RL de CV. Template Design © Learnify LMS. All rights reserved. Terminos y Condiciones Aviso de Privacidad Politica de Devolución
Hide picture