Saltar al contenido
Low-Level AtlasAtlas de Conocimiento
Inicio del Atlas

Capa de entrada

Índice Low-Level Empezá por Acá Lo que Tenés que Saber

Ruta de aprendizaje

00Orientación
Página de fase
01Fundamentos13
Página de fase
Modelo de Máquina13
Resumen Ahora el runtime sos vos La CPU: fetch–decode–execute y el clock Registros y la ISA La jerarquía de memoria Cache lines y localidad Stack vs heap Bits, bytes, words y direcciones Complemento a dos y representación de enteros Endianness IEEE 754 floating point Cómo el fuente se vuelve ejecución El address space del proceso y la memoria virtual
02La Capa C30
Página de fase
C desde el Metal14
Resumen Por qué C todavía importa El sistema de tipos de C es débil (y lo que te cuesta) Undefined behavior: el contrato que no sabías que firma... Más UB: signed overflow, aliasing y sequencing El preprocessor: macros, includes y compilación condici... Translation units, declaraciones vs definiciones y link... Arrays y array-to-pointer decay Structs, unions y bitfields Los strings son solo `char*` (y las consecuencias) Integer promotions y conversiones implícitas La biblioteca estándar mínima (esenciales de libc) Build y ejecución de un programa C desde cero (gcc/clang) Leer el estándar C y cppreference
Punteros y Memoria16
Resumen Qué es realmente un puntero Aritmética de punteros y stride El stack: frames, locales y automatic storage El heap: malloc/free y el allocator por debajo Punteros a punteros (doble indirección) `void*` y type erasure Const-correctness y qué promete realmente `const` Function pointers Struct layout: alineación y padding Data layout y cache-friendliness Strict aliasing y type punning Bug clásico: use-after-free y double-free Bug clásico: buffer overflow y acceso out-of-bounds Bug clásico: memory leaks y disciplina de ownership Allocators propios: arena, pool y bump
03Bajar al Metal27
Página de fase
Assembly y Salida del Compilador13
Resumen Por qué leer assembly — Compiler Explorer como herramie... Registros x86-64 y el register file El core instruction set: `mov`, aritmética, `lea` Addressing modes y operandos de memoria Control flow: jumps, condiciones y el registro de flags El stack a nivel assembly (`push`/`pop`, `rsp`/`rbp`) Stack frames: prólogo y epílogo de función La calling convention System V AMD64 Cómo compilan las construcciones de C: loops, structs, ... Optimización: qué le hace `-O2` a tu código Inline assembly (y cuándo alcanzarlo) Apéndice ARM64: registros AArch64 y calling convention
Toolchain y Linking14
Resumen El pipeline: preprocess → compile → assemble → link Object files y qué tienen adentro El formato ELF (sections, segments, headers) Símbolos: definición, referencia y resolución Static linking y archives (`.a`) Dynamic linking y shared libraries (`.so`) El dynamic loader, relocation, PLT y GOT gcc vs clang y el modelo de compiler driver `make` y el grafo de dependencias de build `cmake` (cuando make no alcanza) gdb / lldb esenciales para debugging de bajo nivel Sanitizers: ASan, UBSan y TSan valgrind y profilers (perf, cachegrind)
04C++ (opcional)13
Página de fase
C++ Moderno13
Resumen C vs C++: qué ganás de verdad (y qué pagás) RAII: la idea que cambia todo Smart pointers: unique_ptr, shared_ptr, ownership Move semantics y value categories Referencias, const y overloading Templates y generic programming La STL: containers, iterators, algorithms Abstracciones de costo cero (y dónde leakéan) Modern C++ (11 → 23): highlights que vale la pena adoptar Error handling: exceptions vs expected Qué subset de C++ usar (y cuál evitar) SerenityOS: un sistema operativo escrito en C++
05Sistemas5
Página de fase
Programación de Sistemas4
Resumen La syscall: cruzar la frontera hacia el kernel Procesos: fork, exec y wait File descriptors e I/O de bajo nivel (`open`/`read`/`wr...
Concurrencia y Performance1
Resumen
06El Proyecto1
Página de fase
OS desde Cero1
Resumen
★Siempre activo1
Página de fase
Craftsmanship de Bajo Nivel1
Resumen

Sistema de referencia

Registros1
Reference Registry
actualizado · 2026-07-19v0.1
⌘K
ENES
GitHub
Inicio/Low-Level/Phase 04 · C++ (optional)
phase~1 min de lecturaActualizado 2026-06-21#phase#cpp#optional
Esta nota todavía no está traducida, así que se muestra la fuente en inglés.

Phase 04 · C++ (optional)

An optional detour. The OS project is C-first, so C++ is here for when its abstractions earn their place — RAII above all. Expand this phase after the C layer is solid, or treat it as a reference.

Read Next

  • Modern C++

Notas relacionadas

C++ ModernoC vs C++: qué ganás de verdad (y qué pagás)C++ agrega lifetime determinístico, abstracciones más fuertes, código genérico y una biblioteca estándar grande sobre acceso tipo C a la máquina, pero pagás con...C++ ModernoError handling: exceptions vs expectedExceptions y return values estilo expected resuelven formas distintas de falla; elegí según localidad, invariantes, política de proyecto y costo de control flow...C++ ModernoModern C++ (11 → 23): highlights que vale la pena adoptarUn recorrido systems-minded por features de C++11 a C++23 que mejoran ownership, generic code, views, errors y diagnostics sin esconder la máquina.C++ ModernoMove semantics y value categoriesMove semantics permite que valores C++ owning recursos transfieran sus guts en vez de copiarlos, pero el mecanismo depende de value categories, rvalue references...

En esta página

Read Next Volver arriba