De la sintaxis de C23 al nivel PhD: punteros, memoria, Meson, sanitizers, ABI, libc/musl, freestanding, concurrencia y tu propia libc.
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La ontología completa: qué es C, dónde vive, cómo se relaciona todo, y un mapa mental de todo el territorio que vas a conquistar.
Historia, filosofía y el lugar de C23 frente a versiones anteriores. La mentalidad del programador de sistemas.
gcc y clang, compilar con -std=c23, tu primer programa y el entorno de desarrollo moderno.
Las cuatro fases: preprocesado, compilación, ensamblado y linking. Qué produce exactamente cada una.
Tipos fundamentales y lo nuevo: auto, constexpr, nullptr, typeof, _BitInt y enums con tipo fijo.
Precedencia, promociones enteras, conversiones implícitas y sus trampas clásicas.
if, switch, bucles y las mejoras de C23. Flujo idiomático, claro y sin sorpresas.
Parámetros, retorno, scope, storage classes e inline. Cómo se organiza y se llama el código.
El concepto que define a C: direcciones, dereferencia, aritmética de punteros y nullptr.
Decaimiento a puntero, arrays de longitud variable y el manejo (peligroso) de cadenas.
Punteros a función, dobles punteros, const correctness y patrones profesionales.
Layout en memoria, alineación, padding, bitfields y flexible array members.
Enumeraciones con tipo subyacente fijo (C23) y el arte de typedef para modelar.
malloc, calloc, realloc y free. El heap, los patrones correctos y los errores clásicos.
Arenas, pools, ownership manual y estrategias de asignación que escalan sin fugas.
Macros, #embed, X-macros y _Generic: la metaprogramación que es posible en C.
Unidades de traducción, headers, extern, y linkage interno frente a externo.
El sistema de build moderno: targets, dependencias, opciones y sanitizers integrados.
Makefiles, autotools y cuándo elegir cada herramienta de construcción.
Crear y usar .a y .so, y las implicaciones profundas de cada tipo de enlace.
Resolución de símbolos, visibilidad, versioning, LTO y el formato ELF por dentro.
La interfaz binaria: System V, convenciones de llamada y estabilidad de ABI.
Qué es una libc, syscalls, POSIX, y las diferencias reales entre glibc y musl.
-ffreestanding, -nostdlib, bare metal y escribir tu propio runtime mínimo.
ASan, UBSan, MSan y TSan: cazar bugs de memoria y comportamiento en ejecución.
clang-tidy, cppcheck, Valgrind y libFuzzer: encontrar bugs antes de que ocurran.
Mitigaciones del compilador, stack protector, secure coding y superficie de ataque.
Hilos C11/C23, atomics, el modelo de memoria y la sincronización correcta.
Inline asm, SIMD/intrinsics, jerarquía de caché, perf y optimización guiada por datos.
El estándar como fuente de verdad, el UB a fondo y cómo lo explota el optimizador.
Tu propia libc mínima, un allocator desde cero y una mirada a los internals del compilador.
El concepto que define a C, la gestión manual del heap y las estrategias que escalan.
constexpr, nullptr, typeof, _BitInt, #embed: el C de siempre, más afilado.
Meson, Make, bibliotecas .a/.so, el linker y el formato ELF por dentro.
Las convenciones de llamada y la interfaz binaria que une el software compilado.
glibc vs musl, las syscalls, y el mundo sin libc: bare metal.
ASan, UBSan, análisis estático y fuzzing: caza bugs antes de que ocurran.
Atomics, el modelo de memoria, SIMD, caché y perf.
Tu propia libc, un allocator desde cero, y cómo funciona un compilador.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →