Saltar al contenido

C23

De la sintaxis de C23 al nivel PhD: punteros, memoria, Meson, sanitizers, ABI, libc/musl, freestanding, concurrencia y tu propia libc.

31 unidades · 151 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología de C y la programación de sistemashechoen curso
  2. 01

    Nivel 1

    5 temas
    1. 01Por qué C hoy y la mentalidad de sistemashechoen curso
    2. 02Una historia con consecuencias: de B a C23hechoen curso
    3. 03Dónde vive C en 2026hechoen curso
    4. 04La filosofía: confianza en el programadorhechoen curso
    5. 05C frente a Rust, Zig y C++hechoen curso
  3. 02

    Nivel 2

    5 temas
    1. 01Setup: el toolchain moderno de Chechoen curso
    2. 02GCC y Clang comparadoshechoen curso
    3. 03Las banderas que importanhechoen curso
    4. 04El editor como IDEhechoen curso
    5. 05Depurar con gdb y lldbhechoen curso
  4. 03

    Nivel 3

    5 temas
    1. 01El proceso de compilación en 4 faseshechoen curso
    2. 02Ver cada fase con tus ojoshechoen curso
    3. 03Del C al ensambladorhechoen curso
    4. 04Unidades de traducción y objetoshechoen curso
    5. 05Compilación separadahechoen curso
  5. 04

    Nivel 4

    5 temas
    1. 01Tipos fundamentales y novedades de C23hechoen curso
    2. 02Enteros con precisión: tamaños reales frente a garantizadoshechoen curso
    3. 03Promociones y conversiones: las reglas que muerdenhechoen curso
    4. 04Coma flotante: IEEE 754, precisión y decimales de C23hechoen curso
    5. 05auto, constexpr y typeof: el C23 que moderniza sin traicionarhechoen curso
  6. 05

    Nivel 5

    5 temas
    1. 01Operadores, expresiones y conversioneshechoen curso
    2. 02Operadores de bits: máscaras, desplazamientos y camposhechoen curso
    3. 03Precedencia y asociatividad: la tabla que de verdad importahechoen curso
    4. 04Puntos de secuencia y orden de evaluaciónhechoen curso
    5. 05sizeof, alignof y la representación en memoriahechoen curso
  7. 06

    Nivel 6

    5 temas
    1. 01Control de flujohechoen curso
    2. 02switch a fondohechoen curso
    3. 03Bucles y su costehechoen curso
    4. 04goto sin vergüenzahechoen curso
    5. 05Salidas no localeshechoen curso
  8. 07

    Nivel 7

    5 temas
    1. 01Funciones, scope y storage classeshechoen curso
    2. 02El stack frame: anatomía de una llamadahechoen curso
    3. 03Punteros a función: despacho, callbacks e interfaceshechoen curso
    4. 04Funciones variádicas: va_list y el interior de printfhechoen curso
    5. 05inline, static y restrict: promesas al optimizadorhechoen curso
  9. 08

    Nivel 8

    5 temas
    1. 01Punteros I: el concepto que define a Chechoen curso
    2. 02El modelo mental correcto: memoria, direcciones y tiposhechoen curso
    3. 03Aritmética de punteros: sumar en unidades de tipohechoen curso
    4. 04const y punteros: leer declaraciones sin equivocarsehechoen curso
    5. 05Los errores clásicos: colgantes, salvajes y dobles liberacioneshechoen curso
  10. 09

    Nivel 9

    5 temas
    1. 01Arrays y stringshechoen curso
    2. 02El decaimiento a punterohechoen curso
    3. 03Arrays multidimensionales y VLAhechoen curso
    4. 04Cadenas en Chechoen curso
    5. 05Manipular texto sin herirtehechoen curso
  11. 10

    Nivel 10

    5 temas
    1. 01Punteros II: función, dobles y consthechoen curso
    2. 02El puntero genérico: void * y el arte de borrar el tipohechoen curso
    3. 03Punteros a punteros: indirección de segundo ordenhechoen curso
    4. 04Aliasing estricto: la regla que rompe optimizacioneshechoen curso
    5. 05Estructuras enlazadas: listas, árboles y container_ofhechoen curso
  12. 11

    Nivel 11

    5 temas
    1. 01Structs, unions y el layout en memoriahechoen curso
    2. 02Disposición en memoria: alineación, padding y empaquetadohechoen curso
    3. 03Unions y type punning: reinterpretar bytes sin romper el lenguajehechoen curso
    4. 04Campos de bits: empaquetar banderas sin fiarse del layouthechoen curso
    5. 05Structs en la práctica: paso, opacidad y miembros flexibleshechoen curso
  13. 12

    Nivel 12

    5 temas
    1. 01Enums y typedefhechoen curso
    2. 02Enums en C23: el tipo subyacente fijohechoen curso
    3. 03typedef: cuándo ayuda y cuándo escondehechoen curso
    4. 04_Generic: sobrecarga en Chechoen curso
    5. 05Modelar el dominio con tiposhechoen curso
  14. 13

    Nivel 13

    5 temas
    1. 01Memoria dinámica: el heaphechoen curso
    2. 02El heap por dentro: brk, mmap y la anatomía de un bloquehechoen curso
    3. 03realloc y el crecimiento: duplicar, mover y perder el punterohechoen curso
    4. 04Fugas y su detección: Valgrind y el sanitizer de direccioneshechoen curso
    5. 05Disciplina de propiedad: quién libera quéhechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01Gestión de memoria avanzadahechoen curso
    2. 02Arena allocatorshechoen curso
    3. 03Pool allocatorshechoen curso
    4. 04La pila como recursohechoen curso
    5. 05Estrategias sin heaphechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01El preprocesador a fondohechoen curso
    2. 02Macros con argumentos: paréntesis, evaluación múltiple y do while 0hechoen curso
    3. 03Stringify y token pasting: los operadores # y ##hechoen curso
    4. 04Compilación condicional: guardas, plataformas y disciplinahechoen curso
    5. 05X-macros: metaprogramación desde una sola listahechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01Modularidad, headers y linkagehechoen curso
    2. 02Los tres linkages: externo, interno y ningunohechoen curso
    3. 03Diseñar una cabecera: qué exponer y qué esconderhechoen curso
    4. 04Variables globales: por qué son venenohechoen curso
    5. 05Estructura de un proyecto Chechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01Build moderno con Mesonhechoen curso
    2. 02Anatomía de un meson.buildhechoen curso
    3. 03Dependencias sin dolorhechoen curso
    4. 04Tests y benchmarkshechoen curso
    5. 05Instalación y distribuciónhechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01Make y el tooling clásicohechoen curso
    2. 02El modelo de Makehechoen curso
    3. 03Reglas de patrón y variableshechoen curso
    4. 04Dependencias de cabecerashechoen curso
    5. 05CMake, Autotools y el panoramahechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01Bibliotecas estáticas y dinámicashechoen curso
    2. 02Bibliotecas estáticashechoen curso
    3. 03Bibliotecas dinámicashechoen curso
    4. 04Versionado y sonamehechoen curso
    5. 05Carga en tiempo de ejecuciónhechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01El linker y el formato ELFhechoen curso
    2. 02Anatomía de un ELF: cabecera, secciones y segmentoshechoen curso
    3. 03Símbolos y reubicaciones: cómo el linker resuelve cada referenciahechoen curso
    4. 04El linker dinámico: ld.so, GOT, PLT y LD_PRELOADhechoen curso
    5. 05Scripts de linker: controlar la disposición de memoriahechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01ABI y convenciones de llamadahechoen curso
    2. 02La convención System V AMD64hechoen curso
    3. 03El stack en detalle: alineación, zona roja y backtracehechoen curso
    4. 04Estabilidad de ABI: qué rompe y qué nohechoen curso
    5. 05Llamadas al sistema: el borde entre tu código y el kernelhechoen curso
  23. 22

    Nivel 22

    5 temas
    1. 01La libc: glibc, musl y las syscallshechoen curso
    2. 02Qué hay dentro de libchechoen curso
    3. 03glibc frente a muslhechoen curso
    4. 04errno y el manejo de erroreshechoen curso
    5. 05Portabilidad: estándar, POSIX y extensioneshechoen curso
  24. 23

    Nivel 23

    5 temas
    1. 01Freestanding: C sin libchechoen curso
    2. 02Hosted frente a freestandinghechoen curso
    3. 03Un binario sin libchechoen curso
    4. 04Reimplementar lo mínimohechoen curso
    5. 05El caso embebidohechoen curso
  25. 24

    Nivel 24

    5 temas
    1. 01Sanitizers: cazar bugs en ejecuciónhechoen curso
    2. 02AddressSanitizer por dentrohechoen curso
    3. 03UndefinedBehaviorSanitizer: el catálogo completohechoen curso
    4. 04ThreadSanitizer y MemorySanitizerhechoen curso
    5. 05Valgrind y los sanitizers en integración continuahechoen curso
  26. 25

    Nivel 25

    5 temas
    1. 01Análisis estático y fuzzinghechoen curso
    2. 02Análisis estático: los bugs que se ven sin ejecutarhechoen curso
    3. 03Fuzzing con libFuzzer: el harness y el corpus que crece solohechoen curso
    4. 04AFL++ y el fuzzing de verdadhechoen curso
    5. 05Cobertura y fuzzing continuo en integración continuahechoen curso
  27. 26

    Nivel 26

    5 temas
    1. 01Seguridad y hardeninghechoen curso
    2. 02Anatomía de un desbordamiento de pilahechoen curso
    3. 03Las defensas del compiladorhechoen curso
    4. 04Vulnerabilidades habitualeshechoen curso
    5. 05Escribir C defensivohechoen curso
  28. 27

    Nivel 27

    5 temas
    1. 01Concurrencia: hilos, atomics y el modelo de memoriahechoen curso
    2. 02Hilos en C: pthreads y el hilo estándarhechoen curso
    3. 03Exclusión mutua: mutex, condiciones e interbloqueoshechoen curso
    4. 04Atómicos y el modelo de memoriahechoen curso
    5. 05Sin bloqueos: compare-and-swap, ABA y por qué casi nuncahechoen curso
  29. 28

    Nivel 28

    5 temas
    1. 01Bajo nivel y rendimientohechoen curso
    2. 02La jerarquía de memoriahechoen curso
    3. 03El procesador modernohechoen curso
    4. 04SIMD y vectorizaciónhechoen curso
    5. 05Medir de verdadhechoen curso
  30. 29

    Nivel 29

    5 temas
    1. 01Undefined Behavior a fondohechoen curso
    2. 02Los tres grises de la normahechoen curso
    3. 03El catalogo del terrorhechoen curso
    4. 04Como el optimizador te castigahechoen curso
    5. 05Convivir con el UBhechoen curso
  31. 30

    Nivel 30

    5 temas
    1. 01PhD: construye lo imposiblehechoen curso
    2. 02Proyecto: un allocator propiohechoen curso
    3. 03Proyecto: un intérprete pequeñohechoen curso
    4. 04Leer código de verdadhechoen curso
    5. 05El modelo mental completohechoen curso