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 01 · Foundations
phase~1 min de lecturaActualizado 2026-06-21#phase#foundations
Esta nota todavía no está traducida, así que se muestra la fuente en inglés.

Phase 01 · Foundations

The reset. Before any code, rebuild the model of the bare machine: the CPU, the memory hierarchy, how data is represented, and how source becomes execution. Almost code-free, entirely load-bearing.

Read Next

  • Machine Model

Notas relacionadas

Low-LevelFase 00 · OrientaciónPor dónde empezar, qué ignorar por ahora y cómo está organizado el Low-Level Atlas.Low-LevelPhase 02 · The C LayerC as a thin layer over the machine, undefined behavior, and manual memory — pointers, the heap, allocators, and the classic bugs.Low-LevelPhase 03 · Down to the MetalReading the assembly your compiler emits, calling conventions, and the full preprocess→compile→assemble→link toolchain with its debuggers.Low-LevelPhase 04 · C++ (optional)The jump from C to C++ — RAII, smart pointers, move semantics, templates, and the STL. Optional, because the OS is C-first.

En esta página

Read Next Volver arriba