Lenguajes de Programación

1: Python

2: JavaScript y TypeScript

3: Rust

4: Shell

1 - Python

Introduction
1. History of Python
  1. Origins and development by Guido van Rossum (1989–1991)
  2. Evolution from Python 1.x → 2.x → 3.x
  3. Design philosophy (PEP 20 — The Zen of Python)
  4. Open source governance and the Python Software Foundation (PSF)
  5. Python Enhancement Proposals (PEPs) and community process
  6. Major milestones (Unicode, async, typing, pattern matching)
2. Python Versions and Compatibility
  1. Python 2 vs Python 3 differences and migration
  2. Maintenance and end-of-life policies
  3. Long-term support (LTS) versions
  4. Semantic versioning and release cadence
  5. Version detection (sys.version, platform.python_version())
  6. Backward and forward compatibility (PEP 563, PEP 585)
3. Installing Python
  1. Official installers (python.org, Microsoft Store, Homebrew, apt, dnf)
  2. Platform-specific installation (Windows, macOS, Linux)
  3. Source builds and configuration options
  4. Multiple Python versions and environment isolation
  5. Verifying installation and PATH configuration
  6. Package managers (apt, brew, choco, scoop)
  7. Alternative distributions (Anaconda, Miniconda, ActivePython)
4. Running Python Scripts and REPL
  1. REPL basics (python, python -i, exit())
  2. Script execution (python script.py, python -m module)
  3. Interactive debugging and inspection (help(), dir())
  4. Command-line flags and options (-O, -B, -m, -X)
  5. Shell integration (ipython, bpython, ptpython)
  6. Jupyter notebooks and interactive kernels
  7. Input/output redirection and pipes
5. IDEs and Code Editors
  1. Full IDEs (PyCharm, VS Code, Spyder, Thonny)
  2. Lightweight editors (Sublime Text, Atom, Vim, Emacs)
  3. REPL integration and interactive terminals
  4. Code completion and IntelliSense
  5. Linters and formatters integration
  6. Debugging tools and breakpoints
  7. Notebooks and mixed-language environments (Jupyter, Colab)
6. Virtual Environments
  1. Environment creation (venv, virtualenv)
  2. Activation and deactivation
  3. Project isolation and dependency management
  4. Environment configuration files (pyvenv.cfg)
  5. Integration with editors and build tools
  6. Cross-platform management (conda, tox, nox)
  7. Reproducibility and sharing (requirements.txt, lock files)
7. Package Management (pip)
  1. Installing, upgrading, uninstalling packages (pip install)
  2. Requirements files (requirements.txt, constraints)
  3. Package discovery and search (pip search, pip index)
  4. Local and editable installs (pip install -e)
  5. Dependency resolution (pip check, pipdeptree)
  6. Source distributions vs wheels
  7. Virtual environment integration
  8. Caching and offline installs (pip download, pip cache)
  9. Custom indexes and mirrors (--index-url, --extra-index-url)
  10. Package auditing and signing (pip-audit, hash-checking-mode)
Fundamentals
1. Basic Data Types
  1. Variables and assignments
    1. Declaration and initialization
    2. Dynamic typing and rebinding
    3. Variable lifetime and scope
  2. Booleans (bool, logical evaluation rules)
  3. Numeric types
    1. int (arbitrary precision, base conversions)
    2. float, decimal, fractions
    3. complex (real/imaginary parts, polar form)
  4. Strings, multiline strings, raw strings
    1. String creation and immutability
    2. Indexing, slicing, concatenation, repetition
    3. f-strings, interpolation, and formatting
    4. Unicode handling and encoding basics
  5. Objects and mutability
    1. Identity vs equality (is vs ==)
    2. Mutable vs immutable built-ins
    3. Copy semantics (copy, deepcopy)
  6. None and sentinel values
    1. Null semantics and truthiness
    2. Sentinel patterns for optional behavior
  7. Hashables and immutability
    1. Requirements for dict/set keys
    2. Custom hash implementation (__hash__, __eq__)
  8. Type conversion and coercion
    1. Implicit vs explicit casting
    2. Numeric promotions
    3. Common built-ins (int(), float(), str(), etc.)
2. Operators
  1. Arithmetic (+, -, *, /, //, %, ``)
  2. Comparison (==, !=, <, >, <=, >=)
  3. Logical (and, or, not)
  4. Bitwise (&, |, ^, ~, <<, >>)
  5. Identity (is, is not)
  6. Membership (in, not in)
  7. Assignment and augmented assignment (+=, -=, etc.)
  8. Walrus operator (:=, PEP 572)
  9. operator module (functional forms of ops)
  10. del statement (object deletion and reference removal)
  11. Operator precedence and associativity
  12. Short-circuit evaluation behavior
3. Control Flow
  1. Conditionals (if, elif, else)
  2. Loops (for, while, for-else, while-else)
  3. Control statements (pass, continue, break)
  4. match / structural pattern matching (PEP 634–636)
    1. Literal, sequence, mapping, and class patterns
    2. OR-patterns and guards (if clauses)
  5. Loop control flags and sentinel conditions
4. Functions
  1. Namespaces and variable lookup rules
  2. Scopes: local, global, nonlocal
  3. Function definition and return semantics
  4. Default argument values and evaluation timing
  5. Keyword and positional arguments
  6. Special parameters (*args, kwargs, /, *)
  7. Argument unpacking (iterables and mappings)
  8. Lambda and anonymous functions
  9. Function attributes (__name__, __doc__, __defaults__, __annotations__)
  10. Closures and free variables
  11. Higher-order functions and decorators (intro)
  12. Callable objects and partial application
5. Exceptions
  1. try, except, else, finally blocks
  2. raise and re-raising
  3. Custom exceptions (inheritance from Exception)
  4. Exception chaining (raise … from …)
  5. Exception groups (PEP 654)
  6. Exception notes (add_note)
  7. Context and traceback objects (sys.exc_info, traceback)
  8. Common built-in exceptions (ValueError, TypeError, etc.)
  9. Suppressing exceptions (contextlib.suppress)
6. Builtins
  1. Keywords (keyword module)
  2. Built-in functions (len, range, map, filter, etc.)
  3. Constants
    1. True, False, None
    2. NotImplemented
    3. Ellipsis (...)
    4. __debug__
  4. Built-in types (int, float, str, list, dict, etc.)
  5. Built-in exceptions (hierarchy and usage)
  6. Standard type hierarchy and object model
7. Modules
  1. Import system (absolute, relative, from, *, aliasing)
  2. Search paths and environment (sys.path, PYTHONPATH)
  3. Module inspection (dir, help, vars, globals, locals)
  4. Basic standard modules
    1. math, cmath
    2. random
    3. os, pathlib
    4. sys
    5. datetime, time
    6. functools, itertools
    7. json, re, collections
Structures and data manipulation
1. Data Structures
  1. Lists
    1. Creation and initialization
    2. Indexing and slicing
    3. Mutability and in-place operations
    4. Methods (append, extend, insert, pop, remove, clear)
    5. Sorting (sort, sorted, key functions, stability)
    6. Membership and iteration
    7. Copying and references
  2. Stacks (list, collections.deque)
    1. LIFO principle
    2. Push/pop operations
  3. Queues (queue.Queue, collections.deque)
    1. FIFO principle
    2. Thread-safe queues (queue, multiprocessing.Queue)
  4. Deques (collections.deque)
    1. Bidirectional operations
    2. Rotation and indexing
    3. Thread safety
  5. Tuples
    1. Immutability and performance
    2. Named tuples (collections.namedtuple, typing.NamedTuple)
    3. Tuple packing and unpacking
  6. Sets
    1. Unique element storage
    2. Set operations (union, intersection, difference, symmetric difference)
    3. Frozen sets
    4. Membership and comprehensions
  7. Dicts and mappings
    1. Key-value pairs
    2. Dictionary methods (get, pop, update, items, keys, values)
    3. Dictionary views and iterators
    4. Default dicts (collections.defaultdict)
    5. OrderedDict, ChainMap, Counter
    6. Dictionary comprehensions
  8. Unpacking and extended unpacking
    1. Parallel assignment
    2. * and `` unpacking in function calls and literals
  9. Comparison between data structures
    1. Performance considerations (lookup, insertion, order)
    2. Mutability, hashability, and ordering
  10. Copying and views
  11. Shallow vs deep copy
  12. copy module
  13. Views (dict.items(), set views)
2. Iterators and Generators
  1. Sequences and iteration protocol
  2. Iterator vs iterable
  3. Built-in functions: iter, next, len, reversed
  4. Custom iterators (__iter__, __next__)
  5. Generators and yield, yield from
  6. Generator expressions and lazy sequences
  7. Infinite iterators (itertools.count, cycle, repeat)
  8. Slices (slice, itertools.islice)
  9. Lazy evaluation and memory efficiency
  10. Generator cleanup and StopIteration
3. Comprehensions
  1. List comprehensions
  2. Set comprehensions
  3. Dict comprehensions
  4. Nested comprehensions
  5. Conditional comprehensions (if and if-else)
  6. Generator expressions vs comprehensions
  7. Performance and readability trade-offs
4. String Manipulation
  1. String operations
    1. Concatenation (+)
    2. Multiplication (*)
    3. Membership (in, not in)
    4. Slicing and indexing
  2. Formatting and interpolation
    1. f-strings
    2. .format()
    3. Old-style % formatting
    4. string.Template
  3. String methods (split, join, replace, strip, startswith, endswith)
  4. Bytes and bytearrays (bytes, bytearray, encoding/decoding)
  5. Format specification mini-language
  6. Utilities (textwrap, string, re, difflib)
  7. Unicode and encodings
    1. unicodedata, normalization (NFC, NFD, NFKC, NFKD)
    2. UTF-8, UTF-16, Latin-1, etc.
  8. uuid module
  9. Advanced operations (str.translate, maketrans, case folding)
5. Regular Expressions
  1. re syntax (groups, lookahead, lookbehind, backreferences)
  2. Flags (IGNORECASE, MULTILINE, DOTALL, VERBOSE)
  3. re module methods (search, match, findall, split, sub, compile)
  4. Regex objects and performance
  5. Third-party regex module (Unicode categories, recursion, timeouts)
  6. Comparison with parsing libraries
    1. fnmatch and glob
    2. parse
    3. shlex and tokenize
    4. string methods vs regex trade-offs
6. Files
  1. File system access
    1. pathlib (modern path interface)
    2. os and os.path
    3. File existence, metadata, and permissions (stat)
  2. File I/O operations
    1. open, close, read, write, append, seek
    2. Context managers (with)
    3. Binary vs text modes
  3. Basic file formats
    1. .ini / config (configparser)
    2. .env (dotenv libraries)
    3. .toml (tomllib, tomli, tomlkit)
    4. .csv (csv, pandas)
    5. .json (json, orjson, ujson)
    6. .sqlite3 (SQL databases)
  4. Serialization
    1. struct (binary data)
    2. codecs
    3. pickle, dill, cloudpickle
    4. marshal
    5. base64, binascii
  5. Temporary files (tempfile)
  6. Compression and archiving
    1. zip/deflate (zipfile)
    2. gzip
    3. bzip2
    4. lzma/lzma2
    5. lz4
    6. xz
    7. zstd
    8. tar (tarfile)
  7. File permissions and metadata (os.stat, chmod, access)
  8. Binary file handling (struct, memoryview, array)
7. Specific Files
  1. Markup
    1. HTML (html, html.parser, BeautifulSoup)
    2. XML (xml.etree.ElementTree, lxml)
  2. Document and ebook
    1. PDF (PyPDF2, fitz)
    2. DOCX (python-docx)
    3. EPUB (ebooklib)
  3. Calendar and scheduling
    1. ICS (ics, icalendar)
    2. CSV-based planners
  4. Mailing and messaging
    1. email, smtplib, imaplib
    2. eml, msg parsing
  5. Image processing
    1. PIL/Pillow
    2. OpenCV
    3. imageio, matplotlib for I/O
  6. Audio processing
    1. wave, aifc, sunau
    2. pydub, audioread, soundfile
  7. Video handling
    1. cv2
    2. moviepy
    3. ffmpeg-python
  8. Security and cryptography
    1. ssl, hashlib, secrets, hmac
    2. Certificate and key handling
  9. Geographic and spatial data
    1. GeoJSON
    2. shapefile, fiona, shapely, geopandas
8. Time and Date
  1. datetime and time modules
  2. calendar module
  3. Time zones (zoneinfo, pytz)
  4. Time arithmetic (timedelta, rounding, truncation)
  5. Parsing and formatting dates (strptime, strftime, dateutil)
  6. High-resolution timers (time.perf_counter, process_time, monotonic)
  7. Scheduling and delays (sleep, sched, asyncio.sleep)
  8. Measuring performance (timeit, perf_counter_ns)
  9. Timestamp conversion and epoch time
Structured and Modular Programming
1. Object-Oriented Programming (OOP)
  1. Classes and objects
    1. Defining and instantiating classes
    2. The __init__ and __new__ methods
    3. The object model and __class__ attribute
  2. Attributes and methods
    1. Class vs instance attributes
    2. Attribute lookup order and MRO
    3. Attribute hiding and naming conventions (_, __)
    4. Dynamic access (getattr, setattr, delattr, hasattr)
  3. Encapsulation and abstraction
    1. Private vs public members (naming conventions)
    2. Getters, setters, and deleters (@property)
    3. Read-only attributes
  4. Inheritance
    1. Single and multiple inheritance
    2. super() and cooperative MRO
    3. Method overriding and extension
    4. Abstract base classes (abc module)
    5. Mixins and shared behavior
    6. Composition vs inheritance
  5. Class mechanics
    1. __slots__ and memory optimization
    2. Metaclasses and dynamic class creation
    3. type() and runtime class manipulation
    4. types module utilities
  6. Special / magic / dunder methods
    1. __repr__, __str__, __len__, __getitem__, etc.
    2. Operator overloading (__add__, __eq__, etc.)
    3. Context management (__enter__, __exit__)
    4. Callable objects (__call__)
    5. Iteration protocols (__iter__, __next__)
  7. Advanced typing and design
    1. Generics and typing.Generic
    2. Protocols (PEP 544)
    3. Covariance and contravariance
    4. Duck typing and structural subtyping
    5. Casting (typing.cast)
  8. Utilities and modern OOP helpers
    1. dataclasses (auto-generated methods, immutability)
    2. attrs (third-party library)
    3. pydantic (data validation models)
    4. enum (enumerations and flag enums)
    5. collections.abc (interfaces for containers)
2. Decorators
  1. Function decorators
    1. Basic decorator syntax
    2. Multiple decorators
    3. @staticmethod, @classmethod, @property
  2. Class decorators
    1. Decorating entire classes
    2. Injecting attributes or methods dynamically
  3. Parameterized decorators
    1. Nested closures for arguments
    2. Factory pattern for decorators
  4. functools.wraps
    1. Preserving metadata (__name__, __doc__)
    2. Common pitfalls and best practices
  5. Practical applications
    1. Logging and timing
    2. Memoization (functools.lru_cache)
    3. Access control and validation
    4. Class registration and plugin systems
3. Modules (advanced)
  1. Packages and __init__.py
    1. Namespace packages (PEP 420)
    2. Relative and absolute imports
    3. Module-level constants and configuration
  2. Standard modules (extended list)
    1. Input/output (io, os, pathlib, shutil)
    2. Argument parsing (argparse, getopt, sys.argv)
    3. Mathematical utilities (math, cmath, statistics)
    4. Data structures (collections, collections.abc, array, enum)
    5. Memory and performance (copy, sys, resource)
    6. Console utilities (curses, readline)
  3. CLI modules
    1. sys, argparse, getopt
    2. Subcommands and command dispatchers
    3. CLI design patterns (subparsers, help messages)
  4. Import system internals
    1. importlib and module reloading
    2. sys.meta_path, loaders and finders
    3. Module caching and sys.modules
    4. Dynamic imports (__import__, importlib.import_module)
    5. Executing packages as scripts (python -m)
4. Logging
  1. logging module fundamentals
    1. Logger hierarchy and propagation
    2. Logging levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
    3. Handlers, formatters, filters
    4. Configuration (basicConfig, dictConfig, fileConfig)
    5. Custom loggers and modular logging
  2. Structured and external logging
    1. JSON logging (jsonlogger)
    2. Log rotation (logging.handlers.RotatingFileHandler)
    3. Integration with monitoring tools (ELK, Prometheus)
  3. Distributed tracing and OpenTelemetry
    1. Traces, spans, and metrics
    2. Exporters and backends
    3. Integration with logging and asyncio
5. Documentation
  1. Docstrings
    1. Inline documentation conventions
    2. Access via help() and .__doc__
  2. Docstring formats
    1. reStructuredText (reST)
    2. Google style
    3. NumPy style
    4. Epydoc and Sphinx roles
  3. doctest (testing from docstrings)
    1. Embedding examples
    2. Running tests from documentation
  4. Documentation generators and renderers
    1. sphinx (reST → HTML/PDF)
    2. readthedocs hosting
    3. mkdocs and Material for MkDocs
    4. pdoc3 (auto API documentation)
    5. Doxygen + Breathe integration
    6. JupyterBook for literate programming
    7. Integration with CI/CD (auto-generated docs)
6. Testing
  1. Testing frameworks
    1. unittest (standard library)
    2. pytest (most popular)
    3. nose2 and legacy options
  2. Code coverage
    1. coverage.py basics
    2. pytest-cov integration
    3. Coverage thresholds and reports
  3. Testing types
    1. Unit Testing (unittest, pytest)
    2. Integration Testing (unittest, pytest)
    3. Functional Testing (unittest, pytest)
    4. Acceptance Testing (unittest, behave)
    5. Regression Testing (unittest, pytest)
    6. Performance Testing (timeit, pytest-benchmark)
    7. Load / Stress Testing (asyncio, locust)
    8. Security Testing (unittest, bandit)
    9. Property-Based Testing (unittest, hypothesis)
    10. Fuzz Testing (unittest, atheris)
    11. Snapshot Testing (unittest, syrupy)
    12. Contract Testing (unittest, pact)
    13. API Testing (http.client, pytest + requests)
    14. UI / E2E Testing (unittest, playwright)
    15. Database Testing (sqlite3, pytest + testcontainers)
    16. Async/Concurrency Testing (asyncio, pytest-asyncio)
    17. Data Quality / Validation Testing (json, great_expectations)
    18. Compatibility / Cross-env Testing (venv, tox)
    19. Smoke / Sanity Testing (unittest, pytest)
    20. Accessibility Testing (unittest, playwright)
  4. Fixtures and parametrization
    1. Test Lifecycle Hooks (unittest setUp/tearDown, pytest)
    2. Fixture Scopes (unittest class/module, pytest function/class/module/session)
    3. Autouse Fixtures (unittest base classes, pytest)
    4. Parametrized Tests (unittest subTest, pytest.mark.parametrize)
    5. Factory Fixtures (unittest helpers, pytest fixture factories)
    6. Temporary Paths and Files (tempfile, pytest.tmp_path)
    7. Environment and Patching (unittest.mock, pytest.monkeypatch)
    8. Capturing Output (contextlib.redirect_stdout, pytest.capsys/capfd)
    9. Logging Capture (logging, pytest.caplog)
    10. Time Control (time, freezegun)
    11. Network Isolation (socket, pytest + responses)
    12. Async Fixtures (asyncio, pytest-asyncio)
    13. Database Fixtures (sqlite3, pytest + testcontainers)
    14. Data Builders (json, factory_boy)
    15. Randomness Control (random, pytest-randomly)
  5. Advanced testing tools
    1. Mocking and Spies (unittest.mock, pytest-mock)
    2. Patch Utilities (unittest.mock.patch, pytest.monkeypatch)
    3. Coverage and Reports (trace, coverage.py)
    4. Parallel and Distributed Tests (multiprocessing, pytest-xdist)
    5. Flaky Test Control (unittest reruns, pytest-rerunfailures)
    6. Timeouts and Slow Tests (signal, pytest-timeout)
    7. Benchmarking (timeit, pytest-benchmark)
    8. Mutation Testing (ast, mutmut)
    9. HTTP Mocking (http.server, responses)
    10. Recording HTTP (VCR) (urllib, vcrpy)
    11. Contract & Schema Testing (json, schemathesis)
    12. Snapshot Testing (pickle, syrupy)
    13. Test Data Generation (random, faker)
    14. Test Selection & Caching (importlib, pytest-testmon)
    15. HTML/Allure Reports (unittest XML, pytest-html)
    16. CI/CD Integration (subprocess, tox)
    17. Profiling for Tests (cProfile, pyinstrument)
    18. Static Analysis (lint/type) (ast, ruff)
    19. Containerized Tests (subprocess, testcontainers)
    20. Async/Trio/AnyIO Tools (asyncio, pytest-anyio)
7. Debugging
  1. Standard debuggers
    1. pdb
    2. bdb, ipdb, pudb
    3. IDE-integrated debuggers (VSCode, PyCharm)
  2. Remote and distributed debugging
    1. debugpy (VSCode protocol)
    2. rpdb, pydevd
  3. Traceback and runtime analysis
    1. Stack traces and frames
    2. Traceback objects and inspection
    3. faulthandler for low-level tracing
  4. Code tracing tools
    1. trace module (execution flow)
    2. inspect module (live introspection)
    3. sys._getframe, locals/globals inspection
    4. Profiling vs debugging differences
  5. Exception debugging
    1. Post-mortem debugging
    2. Context display (contextlib, traceback.print_exc)
    3. Custom exception hooks (sys.excepthook)
Advanced Structures and Functional Programming
1. Functional Programming
  1. Functional paradigms and immutability
  2. Higher-order functions (map, filter, reduce)
  3. Anonymous functions (lambda)
  4. functools utilities
    1. partial, cmp_to_key, cache, lru_cache, reduce
  5. operator module (functional equivalents for arithmetic/logical ops)
  6. Closures and free variables
  7. Currying and partial application
  8. Immutability and purity
  9. Function composition and pipelines
  10. Functional iteration (itertools, more-itertools)
  11. Side effects and referential transparency
  12. Recursion and tail call optimization
  13. Persistent data structures (immutables, pyrsistent)
2. Itertools / Advanced Generators
  1. Combinatorial tools (product, permutations, combinations, combinations_with_replacement)
  2. Accumulators and counters (accumulate, count, cycle, repeat)
  3. Sequence utilities (chain, compress, dropwhile, takewhile, islice, starmap, tee, zip_longest, groupby)
  4. Infinite and lazy sequences (itertools, more-itertools)
  5. Generator delegation (yield from)
  6. Generator-based pipelines and streams (toolz, funcy)
3. Memory Views
  1. Buffer protocol (low-level binary access)
  2. memoryview objects and slicing
  3. Byte arrays and binary manipulation (bytearray, array)
  4. Dict views (keys, items, values)
  5. Shared memory across processes (multiprocessing.shared_memory)
  6. Interfacing with C-level buffers (ctypes, numpy)
4. Benchmarking and Profiling
  1. Timing and microbenchmarks (timeit, perf_counter)
  2. CPU profiling (cProfile, profile, pstats)
  3. Memory profiling (tracemalloc, memory_profiler)
  4. Line-level profiling (line_profiler)
  5. Statistical and sampling profilers (py-spy, scalene, yappi)
  6. Async profiling (aiomonitor, asyncio-run-instrument)
  7. Visualization tools (snakeviz, tuna, speedscope)
  8. Benchmark frameworks (pytest-benchmark, asv)
5. Code Quality Tools
  1. Style and formatting (flake8, autopep8, black, isort)
  2. Type checking (mypy, pyright, pytype)
  3. Linting (pylint, ruff, prospector)
  4. Security analysis (bandit, safety)
  5. Metrics and complexity (radon, wily)
  6. Code modernization (pyupgrade, futurize, modernize)
  7. Git and pre-commit automation (pre-commit, tox, nox)
  8. Docstring and naming validation (pydocstyle, pep8-naming)
  9. Dead code and dependency analysis (vulture, pip-check)
  10. Refactoring tools (rope, bowler)
6. Security
  1. Common Algorithms and Concepts
    1. Symmetric encryption (AES, ChaCha20)
    2. Asymmetric encryption (RSA, ECC)
    3. Hashing (SHA, BLAKE2, PBKDF2)
    4. Key derivation and stretching (scrypt, Argon2)
    5. Digital signatures and verification
    6. Certificates and PEM handling
    7. Public Key Infrastructure (PKI)
    8. Randomness and entropy pools
  2. Standard Library
    1. hashlib (hash algorithms, digests)
    2. secrets (secure randomness)
    3. ssl (TLS, context management)
    4. hmac (hash-based message authentication)
    5. base64 (binary encoding)
  3. Third-Party Libraries
    1. bcrypt
    2. passlib
    3. cryptography
    4. pyjwt
    5. argon2-cffi
    6. fernet
7. Type Hints
  1. Function and variable annotations
  2. typing module fundamentals
  3. Type aliases (TypeAlias)
  4. Generic types (TypeVar, Generic)
  5. Protocols (PEP 544)
  6. Unions and optionals (Union, Optional)
  7. Literal types (Literal)
  8. NewType and nominal typing (NewType)
  9. Typed mappings (TypedDict)
  10. Self type and recursive references (Self, PEP 673)
  11. Parameter and return specifications (ParamSpec, Concatenate, PEP 612)
  12. Advanced static typing (mypy_extensions, typing_extensions)
  13. Runtime type checking (beartype, typeguard)
  14. Dataclass typing and validation (dataclasses, pydantic)
  15. Gradual typing and static analysis (mypy, pyright, ruff --extend-select TYP)
Concurrency, Async, Low Level
1. Async and Concurrency
  1. Thread-based concurrency (threading, concurrent.futures.ThreadPoolExecutor)
  2. Process-based parallelism (multiprocessing, concurrent.futures.ProcessPoolExecutor)
  3. Global Interpreter Lock (GIL) and its implications
  4. Synchronization primitives
    1. Locks (Lock, RLock)
    2. Semaphores, Events, Barriers, Conditions
    3. Queues (queue, asyncio.Queue, multiprocessing.Queue)
  5. Parallelism vs concurrency concepts
  6. Asynchronous programming (asyncio)
    1. async / await keywords
    2. Coroutines and cooperative multitasking
    3. Async iterators and async generators
    4. Async comprehensions
    5. Async context managers (async with)
    6. Event loop internals (asyncio.get_event_loop, policies)
    7. Task scheduling (create_task, gather, wait, shield)
    8. Synchronization primitives (Lock, Event, Semaphore, Condition)
    9. Exception handling and cancellation (CancelledError)
    10. Third-party event loops (uvloop, trio, anyio, curio)
    11. Green threads (greenlet, gevent)
    12. Background tasks and concurrency with async frameworks
    13. Integration with threads and processes (to_thread, run_in_executor)
    14. Async profiling and debugging (aiomonitor, asyncio.run, tracemalloc)
2. Networking
  1. Networking fundamentals
    1. TCP/IP basics
    2. IP addressing and subnetting (ipaddress)
  2. Low-level networking (socket)
    1. TCP and UDP sockets
    2. Non-blocking I/O and selectors
    3. Socket options and timeouts
  3. High-level networking
    1. HTTP protocol basics
    2. URL handling (urllib, urllib3)
    3. HTTP clients (requests, httpx, aiohttp)
    4. WebSockets (websockets, aiohttp, fastapi.websockets)
    5. Email and SMTP (smtplib, imaplib, poplib, email)
    6. FTP and SFTP (ftplib, paramiko)
  4. Web application interfaces
    1. WSGI (wsgiref, flask)
    2. ASGI (fastapi, starlette, aiohttp)
    3. HTTP servers (http.server, aiohttp.web, uvicorn, hypercorn)
  5. Networking concurrency
    1. Async sockets (asyncio.start_server, asyncio.open_connection)
    2. Connection pooling and throttling
    3. DNS and async resolvers (aiodns)
    4. SSL/TLS contexts (ssl)
    5. Performance testing and benchmarking (ab, wrk, locust)
3. Metaprogramming
  1. Metaclasses (type, __new__, __init__)
  2. Descriptors (__get__, __set__, __delete__)
  3. Difference between class decorators and metaclasses
  4. Dynamic class and attribute creation (setattr, getattr)
  5. Attribute access customization (__getattr__, __getattribute__)
  6. Decorator-based metaprogramming patterns
  7. Code generation and reflection (ast, inspect, types)
  8. Runtime modification of objects (monkey patching, proxy classes)
  9. Introspection and dynamic imports (importlib, sys.modules)
4. Context Managers
  1. with statement semantics
  2. Built-in context managers (open, decimal.localcontext, threading.Lock)
  3. contextlib module
    1. contextmanager decorator
    2. ExitStack, redirect_stdout, suppress
  4. Async context managers (async with, @asynccontextmanager)
  5. Custom context managers (__enter__, __exit__)
  6. Resource cleanup and exception safety
  7. Nested and chained contexts (ExitStack)
5. Monitoring
  1. Runtime monitoring (sys.monitoring, PEP 669)
  2. Code tracing (sys.settrace, sys.setprofile)
  3. Logging and telemetry integration (logging, OpenTelemetry)
  4. Application performance monitoring (APM) (sentry-sdk, datadog, newrelic)
  5. Resource usage tracking (resource, psutil)
  6. System-level inspection (os, platform, tracemalloc)
  7. Custom metrics and exporters (prometheus_client)
  8. Distributed tracing (opentelemetry, jaeger-client)
6. Garbage Collection
  1. Reference counting and object lifetime
  2. gc module (manual control, thresholds, debug flags)
  3. Weak references (weakref, WeakKeyDictionary, WeakValueDictionary)
  4. Circular reference detection and cleanup
  5. Finalization and destructors (__del__, atexit)
  6. Object tracking and introspection (gc.get_objects, gc.get_referrers)
  7. Memory leaks and object retention analysis (objgraph, pympler)
  8. Interaction with C extensions and native memory
  9. Performance tuning and garbage collection strategies (gc.freeze, tuning generations)
Implementation & Distribution
1. General Environment Tools
  1. Virtual environments (venv, virtualenv)
  2. Interactive environments (jupyter, IPython)
  3. Package installation and dependency management (pip, requirements.txt)
  4. Modern build systems (pyproject.toml, poetry, flit, uv, pdm)
  5. Conda environments (conda, mamba)
  6. Python version management (pyenv, asdf, tox)
  7. Dependency resolution and locking (pip-tools, poetry.lock, uv.lock)
  8. Environment reproducibility (pip freeze, conda env export)
  9. Project isolation and sandboxes (direnv, nix-shell)
  10. Environment variables and configuration management (dotenv, pydantic-settings)
2. Implementations
  1. Building Python from source (configure, make, installation paths)
  2. CPython internals and command-line interface
    1. Bytecode compilation (dis, compile)
    2. Interpreter flags (-O, -m, -B, -I)
    3. Debug builds and symbol tables
  3. Alternative implementations
    1. PyPy (JIT compiler and performance profiling)
    2. Cython (C extensions, pyximport, cythonize)
    3. Codon (Python-to-native compiler for performance)
    4. MicroPython (embedded systems)
    5. RustPython, GraalPy, Jython, IronPython
  4. Binary distribution
    1. pyinstaller (single-file executables)
    2. cx_Freeze (cross-platform packaging)
    3. nuitka (C++ compilation and optimization)
    4. shiv, pex (self-contained zip apps)
  5. Web runtimes and browser targets
    1. PyScript (Python in HTML, WASM-based)
    2. Pyodide (WASM + scientific stack)
    3. Brython (transpiles Python to JavaScript)
    4. Transcrypt (typed Python → JS transpiler)
  6. Embedding Python in other languages
    1. C API (Python.h)
    2. ctypes and cffi
    3. Integration in C/C++, Rust, and Go projects
    4. Cross-language execution (subprocess, ffi, wasmer)
  7. Extending Python with native code
    1. C extensions and modules
    2. pybind11, Cython, cffi
    3. Shared libraries and ABI compatibility
3. Packaging
  1. Packaging process
    1. setuptools and setup.py
    2. setup.cfg (declarative configuration)
    3. pyproject.toml (PEP 517/518 compliant builds)
    4. Build artifacts (sdist, wheel)
    5. Distribution upload (twine, flit publish, poetry publish)
    6. Package signing and verification (gpg, twine --sign)
  2. Package indexes
    1. PyPI (official package index)
    2. TestPyPI (staging environment)
    3. pypiserver (self-hosted registries)
    4. Private and enterprise registries (devpi, artifactory, nexus)
  3. Versioning and metadata
    1. Semantic versioning (PEP 440)
    2. Metadata and classifiers (setup.cfg, pyproject.toml)
    3. Dynamic versioning tools (setuptools_scm, bumpver, versioneer)
  4. Dependency management and resolution (pip, resolverlib)
  5. Package auditing and signing (pip-audit, gpg, sigstore)
  6. Cross-platform builds and reproducibility (build, cibuildwheel, tox)
4. CLI Apps
  1. CLI argument parsing
    1. argparse (std lib)
    2. optparse (legacy)
    3. getopt (low-level)
  2. Command frameworks
    1. click
    2. typer
    3. python-fire
  3. Console utilities
    1. colorama (color support)
    2. rich (formatting, live tables, progress bars)
    3. prompt_toolkit, inquirer (interactive prompts)
  4. CLI packaging
    1. Entry points (console_scripts)
    2. Shell completion generation
    3. Cross-platform support (os, shutil.which)
5. Graphical Apps
  1. GUI frameworks
    1. tkinter (standard library)
    2. PyQt5, PySide6 (Qt bindings)
    3. Kivy, KivyMD (mobile and touch support)
    4. wxPython (native widgets)
    5. Dear PyGui (immediate-mode GUI)
    6. PyGObject, GTK3/4
  2. Game and multimedia frameworks
    1. pygame, arcade, ursina
  3. GUI builders and design tools (Qt Designer, Glade)
  4. Cross-platform packaging (pyinstaller, briefcase)
6. Internationalization (i18n) and Localization (l10n)
  1. Text translation and message catalogs
    1. gettext (std lib)
    2. babel (third-party)
    3. polib (PO file management)
  2. Locale management (locale, setlocale, environment vars)
  3. Number, date, and currency formatting
    1. babel.numbers, babel.dates
    2. locale.format_string
  4. Unicode normalization and encoding handling (unicodedata)
  5. Time zones and calendars (zoneinfo, dateutil)
  6. Multi-language configuration and packaging (gettext, pybabel extract/update)
Internals
1. Python Compiler & Interpreter
  1. Abstract Syntax Tree (AST) (ast, compile)
  2. Bytecode inspection (dis, opcode)
  3. Tokenization and lexing (tokenize, token)
  4. Lexical analysis and parsing pipeline
  5. Symbol tables and scoping (symtable)
  6. Compilation stages (source → AST → bytecode)
  7. Evaluation loop (CEval)
  8. Frame objects (sys._getframe, inspect)
  9. Code objects (__code__, types.CodeType)
  10. Bytecode caching (.pyc, __pycache__)
  11. Optimization flags (-O, -OO)
  12. Dynamic code execution (eval, exec)
  13. Compile-time constants and folding
  14. Abstract interpretation and future statements (__future__)
2. Execution Model
  1. Call stack and stack frames
  2. Function call mechanics and parameter passing
  3. Coroutine scheduling and task switching (asyncio, trio)
  4. Import execution and module caching (importlib, sys.modules)
  5. Global state and thread safety (threading, contextvars)
  6. Context variables (PEP 567)
  7. Event loop interaction and scheduling
  8. Exception propagation across async boundaries
  9. Interpreted vs compiled function calls (builtin_function_or_method)
  10. Trampolines and frame reuse optimizations
  11. Generator and async state machines
3. Data Model
  1. ctypes and C-compatible structures
  2. Object memory layout and slots (__slots__)
  3. PyObject structure and reference model
  4. Type objects and inheritance hierarchy
  5. Method resolution order (C3 linearization)
  6. Data vs non-data descriptors (__get__, __set__, __delete__)
  7. Dynamic attribute resolution (__getattr__, __getattribute__)
  8. Numeric and sequence protocols (__add__, __getitem__, etc.)
  9. Callable protocol (__call__)
  10. Context manager protocol (__enter__, __exit__)
  11. Iterator protocol (__iter__, __next__)
  12. Coroutine protocol (__await__, __anext__)
  13. Mapping, hashing, and equality semantics (__hash__, __eq__)
4. Python C Model
  1. CPython C API (Python.h)
  2. PyObject structure and reference counting
  3. Extending Python with C modules (PyModuleDef, PyMethodDef)
  4. Embedding Python in C/C++ applications (Py_Initialize, PyRun_SimpleString)
  5. Argument parsing (PyArg_ParseTuple, Py_BuildValue)
  6. Error and exception handling (PyErr_SetString, PyErr_Occurred)
  7. Memory management (Py_INCREF, Py_DECREF)
  8. GIL internals and state management (PyGILState_Ensure, PyEval_SaveThread)
  9. Frame and thread state (PyThreadState, PyInterpreterState)
  10. C API headers (object.h, listobject.h, dictobject.h)
  11. Subinterpreters and isolated runtimes (_xxsubinterpreters, PEP 684)
  12. Cython bridge and interoperability (cython, pyximport)
  13. ABI stability and limited API (Py_LIMITED_API, PEP 384)
  14. Capsule and pointer exchange (PyCapsule)
5. Extensions
  1. Protocols and Foreign Function Interfaces (FFI)
    1. ctypes
    2. cffi
    3. pybind11
    4. SWIG
  2. Inter-language data marshaling and memory safety
  3. Extending and embedding with native languages
    1. C
    2. C++
    3. Rust (PyO3, rust-cpython, maturin)
    4. Go (gopy, cgo, pygo)
  4. WASM integration (wasmer, wasmtime-py)
  5. Cross-language RPC frameworks (grpc, capnp, flatbuffers)
  6. Plugin systems and dynamic loading (importlib.machinery, ctypes.CDLL)
  7. Binary interface and FFI debugging (gdb, valgrind, lldb-python)

2 - JavaScript y TypeScript

Introducción
1. Historia y Evolución de JavaScript y TypeScript
  1. Origen de JavaScript en el navegador (Brendan Eich, 1995)
  2. Estándar ECMAScript y rol de ECMA International
  3. Comité TC39 y proceso de propuestas
  4. Evolución de ECMAScript (ES3, ES5, ES2015+)
  5. Aparición de TypeScript como superconjunto tipado de JavaScript
  6. Filosofía de TypeScript: tipado estático opcional y verificación en tiempo de compilación
  7. Compatibilidad progresiva con JavaScript existente
  8. Influencia de C#, Java y lenguajes estáticos en el diseño de TypeScript
  9. Adopción en backend, frontend y full-stack
  10. Impacto de Node.js en el uso de JavaScript fuera del navegador
  11. Expansión del ecosistema: Deno, Bun y runtimes alternativos
  12. Evolución del tooling: bundlers, transpiladores, linters
  13. Uso de TypeScript en grandes bases de código y monorepos
  14. Transición de JavaScript clásico basado en funciones a clases, módulos y async/await
  15. “Any valid JavaScript is valid TypeScript” como principio de diseño
2. Versiones y Compatibilidad
  1. Versionado semántico de TypeScript
  2. Versionado de Node.js y compatibilidad con ECMAScript
  3. target y lib en tsconfig.json
  4. Downleveling y transpilación (ESNext → ES5)
  5. Compatibilidad con navegadores y entornos legacy
  6. Polyfills y core-js
  7. Características propuestas (stage 0–4) y su adopción en TypeScript
  8. Estabilidad de sintaxis frente a features experimentales
  9. Tipos DOM según versión de @types/web
  10. Estrategias de upgrade mayor de TypeScript en proyectos grandes
  11. Compatibilidad entre módulos ES (import/export) y CommonJS (require/module.exports)
  12. Detección de versión en runtime (process.versions, navigator.userAgent)
  13. Dependencia en especificación del Event Loop del host (browser vs Node)
  14. Compatibilidad entre distintos bundlers y empaquetadores
  15. Compatibilidad entre ts-node, tsx, babel, esbuild
3. Instalación del Entorno
  1. Instalación de Node.js (instalador oficial)
  2. Instalación con nvm / fnm / asdf
  3. Instalación de Deno
  4. Instalación de Bun
  5. npm como package manager por defecto
  6. yarn clásico y yarn modern
  7. pnpm y almacenamiento global basado en content-addressable store
  8. Instalación global de typescript (npm install -g typescript)
  9. Instalación local de typescript como dependencia de desarrollo
  10. Verificación de node, npm, tsc en PATH
  11. Configuración inicial de proyecto (npm init, pnpm init, yarn init)
  12. Inicialización de TypeScript (tsc --init)
  13. Estructura de carpetas recomendada (src, dist, test)
  14. Soporte multiplataforma (Windows, macOS, Linux)
  15. Contenedores y devcontainers (Dockerfile, devcontainer.json)
4. Ejecución de Código y REPL
  1. Ejecución directa de JavaScript con node archivo.js
  2. REPL interactivo de Node.js
  3. Ejecución directa de TypeScript con ts-node
  4. Ejecución directa de TypeScript con tsx
  5. Ejecución TypeScript nativa en Deno
  6. Ejecución TypeScript nativa en Bun
  7. Compilación explícita con tsc y luego ejecución con Node.js
  8. Flags comunes de Node (--inspect, --require, --experimental-*)
  9. Flags comunes de ts-node / tsx
  10. Uso de importaciones ES en Node ("type": "module")
  11. Uso de la consola del navegador como entorno interactivo
  12. Ejecución en entornos sandbox (CodeSandbox, StackBlitz)
  13. I/O estándar (stdin, stdout, stderr) en Node
  14. Pipes y redirección de salida en CLI de Node
  15. Hot reload durante desarrollo con nodemon, ts-node-dev
5. IDEs y Editores
  1. Visual Studio Code y el Language Service de TypeScript
  2. WebStorm / IntelliJ IDEA con soporte TypeScript integrado
  3. Neovim con LSP (typescript-language-server)
  4. Vim con coc.nvim y extensiones TS
  5. Emacs con lsp-mode y tide
  6. Autocompletado, IntelliSense y sugerencias de tipo
  7. Navegación de código (Go to Definition, Find References)
  8. Refactorizaciones automáticas (renombrar símbolos, extraer funciones)
  9. Soporte de linters (ESLint) integrado en el editor
  10. Formato automático con Prettier
  11. Integración de debuggers (Chrome DevTools, Node Inspector)
  12. Integración con Git y control de versiones
  13. Snippets y plantillas de código repetitivo
  14. Diagnóstico en tiempo real del compilador de TypeScript
  15. Entornos de notebooks JS/TS (Quokka, Jupyter con kernels JS)
6. Entornos de Proyecto y Aislamiento
  1. node_modules como entorno aislado por proyecto
  2. package.json como descriptor de entorno
  3. package-lock.json, yarn.lock, pnpm-lock.yaml
  4. Resolución determinista de dependencias
  5. Workspaces (yarn workspaces, pnpm workspaces, npm workspaces)
  6. Monorepos y herramientas (turbo, nx, lage)
  7. Separación entre dependencias de runtime (dependencies) y de build (devDependencies)
  8. Scripts de proyecto (npm run, pnpm run)
  9. Estrategias de versionado interno en monorepos
  10. Aislamiento por versión de Node usando nvm dentro del proyecto
  11. Contenedores reproducibles para desarrollo (Docker Compose)
  12. Variables de entorno (.env, dotenv, process.env)
  13. Reproducibilidad de builds en CI
  14. Caché incremental de transpilación y bundling
  15. Estándares de estructura de carpetas (src, lib, dist, scripts)
7. Gestión de Paquetes y Dependencias
  1. npm install, npm update, npm uninstall
  2. yarn add, yarn remove, yarn upgrade
  3. pnpm add, pnpm remove, pnpm update
  4. Versiones fijas vs rangos (^, ~, *)
  5. Dependencias opcionales y peer dependencies
  6. Resolución de conflictos de versiones
  7. Auditoría de dependencias (npm audit, pnpm audit)
  8. Firma y verificación de integridad (shasum)
  9. Repositorios privados (Artifactory, Verdaccio)
  10. Instalaciones link/workspace locales
  11. Publicación de paquetes internos
  12. Tipos externos (@types/*) para librerías JS puras
  13. Mantenimiento de typesVersions en librerías TypeScript
  14. Dependencias transpiladas vs dependencias puras ESM
  15. Gestión de binarios nativos precompilados
8. Herramientas del Ecosistema Web
  1. Bundlers (webpack, esbuild, rollup, vite)
  2. Compilación incremental y HMR (Hot Module Replacement)
  3. Transformación con Babel
  4. Minificación y tree-shaking
  5. Code splitting y lazy loading
  6. Sourcemaps y depuración en el navegador
  7. Polyfills automáticos según destino
  8. Linter y formateador integrados en pipeline de build
  9. Pruebas unitarias integradas en bundlers (vitest)
  10. Empaquetado para navegadores antiguos
  11. Empaquetado para runtimes edge
  12. Bundles isomórficos (SSR + CSR)
  13. Configuración multi-target (web, node, worker)
  14. Generación de tipos .d.ts
  15. Publicación de librerías como ESM y CJS
Fundamentos
1. Tipos Básicos y el Sistema de Tipos de TypeScript
  1. Declaración de variables con let, const, var
  2. Inferencia de tipos
  3. Anotaciones de tipo explícitas
  4. Tipos primitivos (string, number, boolean)
  5. Tipos null, undefined, void
  6. Tipos bigint y symbol
  7. Tipos literales ("ok", 42, true)
  8. Tipos unión (|)
  9. Tipos intersección (&)
  10. Tipos any, unknown, never
  11. Alias de tipo (type)
  12. Interfaces (interface)
  13. Tuplas ([T, U])
  14. Enums (enum, const enum)
  15. Objetos con propiedades opcionales y readonly
2. Operadores
  1. Operadores aritméticos (+, -, *, /, %, **)
  2. Operadores de asignación compuesta (+=, -=, *=, etc.)
  3. Operadores de comparación (===, !==, <, >, <=, >=)
  4. Operadores lógicos (&&, ||, !)
  5. Operador de fusión nula (??)
  6. Operador de encadenamiento opcional (?.)
  7. Operadores bitwise (&, |, ^, ~, <<, >>, >>>)
  8. Operador ternario (cond ? A : B)
  9. Operadores de propagación (...spread)
  10. Destructuración de arrays y objetos
  11. Precedencia y asociatividad de operadores
  12. Cortocircuito en ||, && y ??
  13. Coerción implícita con == vs comparación estricta ===
  14. delete para eliminar propiedades de objetos
  15. in y instanceof para verificación de pertenencia y tipo
3. Control de Flujo
  1. if, else if, else
  2. switch y case
  3. for, for...of, for...in
  4. while y do...while
  5. break y continue
  6. Etiquetas de bucle (label:)
  7. Bloques con {} y alcance léxico
  8. Guard clauses y retornos tempranos
  9. throw para interrupción de flujo
  10. Narrowing de tipos dentro de condiciones
  11. Type guards personalizados con predicados (param is Tipo)
  12. Flujo de control basado en in, typeof, instanceof
  13. Exhaustividad en switch con never
  14. Assertions de no-nulo (!)
  15. Patrones de control de flujo funcional (array.filter, array.map)
4. Funciones
  1. Declaraciones de función (function foo() {})
  2. Funciones flecha (const f = () => {})
  3. Parámetros tipados
  4. Parámetros opcionales (param?: T)
  5. Parámetros con valor por defecto
  6. Parámetros rest (...args: T[])
  7. Tipado de retorno explícito
  8. Funciones que retornan void
  9. Funciones que nunca retornan (never)
  10. Sobrecarga de funciones (signaturas múltiples)
  11. Funciones genéricas (<T>)
  12. Clausuras y entorno léxico
  13. this y binding explícito
  14. call, apply, bind
  15. Funciones async (async function)
5. Errores y Excepciones
  1. try, catch, finally
  2. Lanzar errores (throw new Error())
  3. Tipado del valor capturado en catch
  4. Errores síncronos vs rechazos de Promesas
  5. Errores personalizados (class MiError extends Error)
  6. Rechazo de Promesas sin catch
  7. Manejo de errores en funciones async/await
  8. Promise.catch y try/catch async
  9. Errores de tipo (TypeError, RangeError, etc.)
  10. Assertions de tipo mal usadas y errores en runtime
  11. Enmascaramiento de errores con any
  12. Estrategias de logging de errores
  13. Errores fatales en Node (process.exit)
  14. Manejo centralizado de errores en aplicaciones web
  15. Errores recuperables vs no recuperables
6. Entorno Global y Builtins
  1. Objeto global (globalThis)
  2. Objetos estándar (Object, Array, Map, Set)
  3. Math y operaciones numéricas
  4. Date y tiempo en milisegundos
  5. JSON (parse/stringify)
  6. console para salida estándar
  7. Promise como primitiva de async
  8. Symbol como clave única
  9. BigInt para enteros grandes
  10. RegExp para expresiones regulares
  11. Error y subclases integradas
  12. URL y URLSearchParams
  13. Intl e internacionalización
  14. TextEncoder / TextDecoder
  15. AbortController y cancelación
7. Módulos e Imports
  1. Módulos ES (import, export)
  2. Importaciones por nombre y por defecto
  3. Reexportaciones (export * from)
  4. Import dinámico (import())
  5. Namespaces internos en TypeScript (namespace, legado)
  6. CommonJS (require, module.exports)
  7. Uso de "type": "module" en Node
  8. Resolución de rutas relativas y absolutas
  9. Alias de paths en tsconfig.json (paths, baseUrl)
  10. Barrel files (index.ts)
  11. Separación de tipos y valores en imports (import type)
  12. export type para exponer sólo tipos
  13. Árbol de dependencias y ciclos
  14. Side effects de módulos
  15. División lógica por capas (domain, infra, ui)
8. Plataforma y Entorno de Ejecución
  1. DOM y APIs del navegador
  2. Node.js y APIs del sistema de archivos
  3. Web Workers y aislamiento de hilos en navegador
  4. Service Workers y ciclo offline
  5. APIs WebCrypto
  6. fetch y red HTTP
  7. Web Storage (localStorage, sessionStorage)
  8. IndexedDB
  9. Streams en navegador
  10. Streams en Node (fs.createReadStream)
  11. Timers (setTimeout, setInterval)
  12. Event Loop (cola de tareas y microtareas)
  13. APIs de proceso en Node (process, os)
  14. Variables de entorno y configuración
  15. Interoperabilidad entre frontend y backend con el mismo lenguaje
Estructuras y Manipulación de Datos
1. Estructuras de Datos Fundamentales
  1. Arrays dinámicos (Array<T>)
  2. Tuplas tipadas en TypeScript
  3. Objetos literales como mapas clave-valor
  4. Map y WeakMap
  5. Set y WeakSet
  6. Pilas (stack) basadas en arrays
  7. Colas (queue) basadas en arrays
  8. Colas dobles (deque) con estructuras circulares
  9. Árboles y tries implementados en objetos/Map
  10. Grafos representados con listas de adyacencia
  11. Tablas hash y colisiones (visión conceptual)
  12. Inmutabilidad estructural con readonly
  13. Clonado superficial vs profundo (structuredClone)
  14. Comparación por referencia vs comparación por valor
  15. Uso de Object.freeze
2. Iteradores y Generadores
  1. Protocolo iterable ([Symbol.iterator])
  2. Protocolo async iterable ([Symbol.asyncIterator])
  3. for...of para recorrer iterables
  4. Generadores (function*)
  5. Generadores async (async function*)
  6. yield y comunicación bidireccional
  7. Iteradores personalizados en clases
  8. Consumo manual de iteradores (next())
  9. Generadores como reemplazo de estados internos complejos
  10. Streams de datos perezosos
  11. Composición de generadores
  12. Uso de generadores para testing y mocking
  13. Adaptación de callbacks a iterables async
  14. Backpressure conceptual en flujos iterables
  15. Comparación entre for...of y métodos de array
3. Arrays y Métodos Funcionales
  1. push, pop, shift, unshift
  2. slice y splice
  3. map para transformación
  4. filter para selección
  5. reduce para acumulación
  6. some y every
  7. find y findIndex
  8. flat y flatMap
  9. Ordenamiento con sort
  10. Comparadores personalizados en sort
  11. Copia inmutable con el spread [...arr]
  12. Particionamiento y groupBy (patrones comunes)
  13. Deduplicación usando Set
  14. Zipping y combinaciones de arrays
  15. Arrays tipados (Uint8Array, Float32Array, etc.)
4. Manipulación de Strings y Texto
  1. Literales de string simples y template strings
  2. Concatenación y +
  3. Substrings y slice
  4. Búsqueda (indexOf, includes, startsWith, endsWith)
  5. Reemplazo (replace, replaceAll)
  6. División (split)
  7. Unión (join) desde arrays
  8. Normalización Unicode (normalize)
  9. Interpolación con template literals
  10. Construcción incremental de strings (buffers de strings)
  11. Codificación y decodificación (TextEncoder, TextDecoder)
  12. Serialización y deserialización JSON (JSON.stringify, JSON.parse)
  13. Escapado seguro para HTML (patrones)
  14. Plantillas etiquetadas (tagged templates)
  15. Internacionalización de texto con Intl.MessageFormat (visión general)
5. Expresiones Regulares
  1. Literales /patrón/flags
  2. Constructor new RegExp()
  3. Flags comunes (g, i, m, s, u, y)
  4. Grupos de captura
  5. Grupos con nombre ((?<name>...))
  6. Lookahead y lookbehind
  7. Cuantificadores (+, *, {m,n})
  8. Límites de palabra y línea (\b, ^, $)
  9. Métodos test, exec
  10. Métodos de string que aceptan regex (match, matchAll, replace, split)
  11. Rendimiento y backtracking excesivo
  12. Sanitización de entradas dinámicas en regex
  13. Comparación regex vs parseadores dedicados
  14. Construcción dinámica de patrones seguros
  15. Patrones comunes para validación de datos
6. Archivos, Streams y Datos Binarios
  1. Sistema de archivos en Node (fs.readFile, fs.writeFile)
  2. Streams legibles y escribibles en Node (fs.createReadStream)
  3. Pipes (readable.pipe(writable))
  4. Buffers (Buffer)
  5. Lectura de binarios (Buffer, Uint8Array)
  6. Escritura incremental de logs y datos
  7. Manejo de archivos grandes sin cargar todo a memoria
  8. Blob y File en el navegador
  9. Descarga de archivos en navegador (creación de enlaces dinámicos)
  10. Subida de archivos con FormData
  11. fetch con ReadableStream
  12. Streams web (ReadableStream, WritableStream, TransformStream)
  13. Compresión y descompresión en Node (módulo zlib)
  14. Archivos temporales y directorios temporales
  15. Permisos y rutas en distintos sistemas operativos
7. Datos Especializados y Formatos
  1. CSV (parseo manual y librerías)
  2. JSON estructurado
  3. YAML y TOML en configuración
  4. XML y DOMParser
  5. HTML como árbol DOM
  6. Markdown como formato de contenido
  7. Binary blobs (imágenes, audio)
  8. ArrayBuffer y DataView
  9. Estructuras binarias con offsets fijos
  10. WebSockets como canal binario o texto
  11. IndexedDB como base de datos del navegador
  12. LocalStorage / SessionStorage como key-value store
  13. Cache Storage en Service Workers
  14. Serialización estructurada (structuredClone)
  15. Mensajería entre hilos (postMessage)
8. Tiempo y Fechas
  1. Objeto Date
  2. Timestamp en milisegundos desde Epoch
  3. Date.now() y mediciones rápidas
  4. Formateo manual de fechas
  5. Librerías de fechas (luxon, date-fns)
  6. Zonas horarias e Intl.DateTimeFormat
  7. Parseo de cadenas de fecha
  8. Medición de rendimiento con performance.now()
  9. setTimeout y temporizadores
  10. setInterval y loops periódicos
  11. Cancelación de temporizadores (clearTimeout, clearInterval)
  12. Animaciones ligadas a requestAnimationFrame
  13. Sincronización de relojes entre cliente y servidor
  14. Cuestiones de DST y horario de verano
  15. Desfase entre reloj del sistema y reloj del servidor
Programación Estructurada y Modular
1. Programación Orientada a Objetos (POO) en TypeScript/JavaScript
  1. Clases (class)
  2. Constructores (constructor)
  3. Propiedades de instancia
  4. Propiedades estáticas
  5. Métodos de instancia y estáticos
  6. Herencia con extends
  7. super y sobreescritura de métodos
  8. Modificadores de acceso (public, private, protected)
  9. Campos readonly
  10. Campos opcionales en clases
  11. Clases abstractas (abstract class)
  12. Métodos abstractos
  13. Interfaces como contratos de clases
  14. Implementación múltiple de interfaces
  15. Mixins y composición en lugar de herencia múltiple
2. Decoradores y Metadatos
  1. Decoradores de clase
  2. Decoradores de método
  3. Decoradores de propiedad
  4. Decoradores de parámetro
  5. Metadata Reflection (reflect-metadata)
  6. Patrones de inyección de dependencias con decoradores
  7. Decoradores para validación
  8. Decoradores para logging y trazas
  9. Decoradores para binding automático de this
  10. Decoradores en frameworks (Angular, NestJS)
  11. Estado de estandarización de decoradores TC39
  12. Implicancias en tree-shaking y minificación
  13. Uso de decoradores en tests y mocks
  14. Decoradores y compatibilidad con emitDecoratorMetadata
  15. Consideraciones de rendimiento y orden de evaluación
3. Módulos, Capas y Arquitectura
  1. Patrones de organización por dominio
  2. Patrones de organización por tipo (controllers, services, utils)
  3. Capas de infraestructura, dominio y aplicación
  4. Capas de UI, lógica y acceso a datos
  5. Módulos ES y carga estática
  6. Carga dinámica con import()
  7. CommonJS en entornos legacy
  8. Barrel modules (index.ts)
  9. Separación entre tipos y valores (import type)
  10. Evitar dependencias circulares
  11. Namespaces internos (histórico en TS)
  12. API pública vs detalles internos
  13. Versionado semántico de módulos internos
  14. Gestión de rutas absolutas con paths en tsconfig.json
  15. Monorepos con múltiples paquetes versionados
4. Logging y Observabilidad
  1. console.log, console.warn, console.error
  2. Loggers estructurados (pino, winston)
  3. Niveles de log (debug, info, warn, error)
  4. Serialización segura de objetos en logs
  5. Formato JSON para logs machine-readable
  6. Logging en el navegador vs logging en Node
  7. Redacción de datos sensibles en logs
  8. Logs de rendimiento y tiempos de respuesta
  9. Integración con sistemas externos (APM)
  10. Trazas distribuidas (traceId, spanId)
  11. Métricas y contadores personalizados
  12. Alertas basadas en logs
  13. Integración con console.group y console.table
  14. Uso de debug namespaced en Node
  15. Logging condicional según NODE_ENV
5. Documentación y Comentarios de Tipo
  1. Comentarios JSDoc
  2. Etiquetas @param, @returns, @deprecated
  3. Comentarios de tipo en JavaScript con // @ts-check
  4. Inferencia de tipos a partir de JSDoc
  5. TSDoc y convenciones para librerías públicas
  6. Generación automática de documentación de API
  7. Documentación en línea para funciones públicas
  8. Documentación para consumidores externos vs internos
  9. Comentarios de intención vs comentarios obvios
  10. Contratos de interfaz y documentación de invariantes
  11. Versionado de la documentación junto al código
  12. README técnicos por paquete
  13. Diagramas de arquitectura en monorepos
  14. Uso de /** @internal */ y visibilidad interna
  15. Control de documentación para clientes externos en SDKs
6. Testing
  1. jest como framework de pruebas
  2. vitest y entornos ESM
  3. mocha + chai
  4. uvu, tape y frameworks minimalistas
  5. Pruebas unitarias
  6. Pruebas de integración
  7. Pruebas de extremo a extremo (E2E)
  8. Pruebas en navegador con Playwright
  9. Pruebas de API con Supertest / fetch mockeado
  10. Snapshots de UI
  11. Cobertura de código (coverage, istanbul, c8)
  12. Mocks y espías (jest.fn)
  13. Fixtures reutilizables
  14. Tests async/await y control de timers falsos
  15. Ejecución de tests en CI/CD
7. Depuración
  1. Debugger en Chrome DevTools
  2. Debugger en VS Code (launch.json)
  3. node --inspect y el inspector de Node
  4. Breakpoints condicionales
  5. debugger; en el código
  6. Sourcemaps para mapear TypeScript → JavaScript
  7. Inspección de pila de llamadas (stack trace)
  8. Inspección de variables locales en tiempo real
  9. Watch expressions en el debugger
  10. Performance Profiler en navegador
  11. Heap snapshot para memoria
  12. Análisis de fugas de memoria en Node
  13. Depuración de Promesas rechazadas
  14. Seguimiento de eventos async en DevTools
  15. Depuración remota en contenedores y servidores
8. Patrones de Diseño y Buenas Prácticas
  1. Programación funcional vs POO en JavaScript moderno
  2. Patrón módulo
  3. Patrón fábrica
  4. Patrón singleton
  5. Patrón estrategia
  6. Patrón adaptador
  7. Patrón fachada
  8. Patrón decorador (a nivel de objetos)
  9. Patrón observador (EventEmitter)
  10. Inyección de dependencias
  11. Patrón repositorio en capas de datos
  12. Patrón builder y objetos inmutables
  13. Patrón middleware (pipelines de funciones)
  14. Separación de concerns entre dominio y framework
  15. Diseño orientado a interfaces en TypeScript
Estructuras Avanzadas y Programación Funcional
1. Programación Funcional
  1. Funciones puras
  2. Inmutabilidad de datos
  3. Evitar efectos secundarios
  4. map, filter, reduce como patrones
  5. Composición de funciones
  6. Currificación y partial application
  7. Funciones de orden superior
  8. Aplicaciones point-free
  9. Inmutabilidad estructural con readonly
  10. Patrones de actualización inmutable con spread
  11. Librerías de FP (Ramda)
  12. Monads y Either / Result (patrones funcionales)
  13. Option / Maybe como alternativa a null
  14. Validación funcional de datos
  15. Manejo funcional de errores en Promesas
2. Iterables Avanzados y Generadores
  1. Iteración lazy para eficiencia
  2. Pipelines de datos con generadores
  3. Transformaciones paso a paso sin arrays intermedios
  4. Generadores async para streams remotos
  5. Consumo incremental de APIs paginadas
  6. Backpressure conceptual en streams async
  7. Coordinación de multitarea con generadores
  8. Implementación de Symbol.iterator
  9. Implementación de Symbol.asyncIterator
  10. Reintentos y recolección gradual de datos
  11. Iteradores infinitos controlados
  12. Conversión entre generadores y arrays
  13. Iteración sobre estructuras personalizadas
  14. for await...of en flujo async
  15. Patrones de pausar y reanudar ejecución
3. Buffers Binarios y Vistas de Memoria
  1. ArrayBuffer
  2. DataView
  3. Typed arrays (Uint8Array, Float64Array)
  4. Interpretación de datos binarios crudos
  5. Endianness y lectura multibyte
  6. Construcción de protocolos binarios personalizados
  7. Conversión entre Buffer (Node) y typed arrays
  8. Serialización eficiente para red
  9. WebSockets binarios
  10. WebRTC DataChannels binarios
  11. Transferencia de memoria entre hilos (postMessage con transfer)
  12. Uso en criptografía y hashing
  13. Parsing de archivos multimedia
  14. Procesamiento de audio en tiempo real
  15. Integración con WebAssembly (memoria compartida)
4. Rendimiento y Profiling
  1. Micro-optimizaciones vs optimización algorítmica
  2. Complejidad temporal y espacial en JS/TS
  3. Perfilador de rendimiento del navegador
  4. Perfilador de CPU en Node
  5. Perfilador de heap y memory leaks
  6. performance.now() y medición precisa
  7. console.time y console.timeEnd
  8. Optimización de loops
  9. Evitar trabajo innecesario en renders UI
  10. Evitar bloqueos del Event Loop
  11. Web Workers para tareas pesadas
  12. División de código (code splitting)
  13. Carga diferida (lazy loading)
  14. Caché de resultados (memoización)
  15. Optimización de serialización/deserialización JSON
5. Calidad de Código y Estándares
  1. ESLint
  2. Reglas de estilo y convenciones del equipo
  3. Prettier como formateador de código
  4. Reglas específicas de TypeScript (@typescript-eslint)
  5. Reglas de seguridad (no eval, no Function dinámica insegura)
  6. Reglas de complejidad ciclomática
  7. Reglas de longitud de archivo y función
  8. Detección de dead code
  9. Análisis estático del flujo de null/undefined
  10. Revisiones de código (pull requests)
  11. Hooks de pre-commit (lint-staged, husky)
  12. Convenciones de nombres (camelCase, PascalCase, UPPER_CASE)
  13. Convenciones de carpetas (utils, services, components)
  14. Convenciones para manejo de errores
  15. Documentación de decisiones arquitectónicas
6. Seguridad y Criptografía
  1. Modelos de amenaza en aplicaciones web
  2. XSS (Cross-Site Scripting)
  3. CSRF (Cross-Site Request Forgery)
  4. Inyección de código en templates
  5. Validación y sanitización de input
  6. DOMPurify y sanitización HTML
  7. CORS y restricciones de origen
  8. Content Security Policy (CSP)
  9. Gestión de tokens y cookies seguras
  10. Almacenamiento seguro en localStorage vs cookies
  11. crypto.subtle y WebCrypto API
  12. Hashing y firma digital en el navegador
  13. Seguridad en Node (fugas de secretos en logs)
  14. Dependencias vulnerables y npm audit
  15. Gestión de secretos en variables de entorno
7. Tipado Avanzado en TypeScript
  1. Tipos genéricos (<T>)
  2. Restricciones de genéricos (<T extends U>)
  3. Tipos condicionales (T extends U ? X : Y)
  4. Tipos inferidos en condicionales (infer)
  5. Tipos mapeados ({[K in Keys]: ...})
  6. keyof y manipulación de llaves
  7. Index signatures ([key: string]: T)
  8. readonly en tipos
  9. Remapeo de modificadores (-readonly, ?)
  10. Utility types estándar (Partial, Required, Pick, Omit)
  11. Record<K,V> y diccionarios tipados
  12. ReturnType, Parameters, ConstructorParameters
  13. ThisType y tipado contextual de this
  14. Inferencia contextual en funciones flecha
  15. Branding y nominal typing (patrón type ID = string & {__brand: "ID"})
8. Validación de Datos y Esquemas
  1. Validación en runtime vs chequeo estático
  2. Zod y esquemas tipados
  3. io-ts y decodificación segura
  4. Validación de requests HTTP
  5. Validación de respuestas de APIs externas
  6. Aserciones de tipo (asserts value is Tipo)
  7. Narrowing manual con validadores
  8. Serialización segura para persistencia
  9. Sanitización de datos antes de guardarlos
  10. Transformaciones de entrada (DTOs)
  11. Contratos entre capas frontend y backend
  12. Tipos compartidos entre cliente y servidor
  13. Versionado de esquemas de datos
  14. Compatibilidad hacia atrás en APIs
  15. Migraciones de estructura de datos en el tiempo
Concurrencia, Async y Bajo Nivel
1. Async y Concurrencia en JavaScript
  1. Modelo single-threaded y Event Loop
  2. Promise como unidad básica de async
  3. async / await
  4. Estados de una Promesa (pending, fulfilled, rejected)
  5. Cadena de Promesas con .then
  6. Manejo de errores con .catch
  7. Ejecución paralela con Promise.all
  8. Ejecución competitiva con Promise.race
  9. Ejecución tolerante a fallas con Promise.allSettled
  10. Control de concurrencia con colas y semáforos userland
  11. Espera activa vs espera pasiva
  12. Bloqueos del Event Loop y CPU-bound
  13. Uso de Web Workers para CPU-bound en navegador
  14. Uso de worker_threads en Node
  15. Cancelación cooperativa con AbortController
2. Networking y Comunicación
  1. fetch y solicitudes HTTP
  2. XMLHttpRequest (legado)
  3. WebSockets
  4. Server-Sent Events (SSE)
  5. gRPC-Web (patrones)
  6. Protocolos binarios sobre TCP en Node (net)
  7. HTTPS en Node (https)
  8. HTTP/2 y multiplexación
  9. Tiempo de espera y reintentos
  10. Política de mismo origen en navegador
  11. CORS y credenciales
  12. Serialización y deserialización JSON
  13. Streaming de respuesta con ReadableStream
  14. Subida de archivos en trozos (chunked upload)
  15. APIs en tiempo real y suscripción de eventos
3. Multithreading, Workers y Paralelismo
  1. Web Workers en navegador
  2. Dedicated Workers vs Shared Workers
  3. Transferencia de buffers entre hilos
  4. SharedArrayBuffer
  5. Atomics y sincronización de memoria compartida
  6. worker_threads en Node
  7. Clustering de procesos en Node (cluster)
  8. Balanceo de carga en múltiples workers
  9. Comunicación entre workers con postMessage
  10. Aislamiento de estado y side effects
  11. Pools de workers
  12. Limitaciones de acceso al DOM en Web Workers
  13. Aceleración de tareas pesadas (compresión, hashing)
  14. Streams entre threads
  15. Diseño de pipelines paralelos
4. Metaprogramación y Reflexión
  1. Proxy para interceptar acceso a objetos
  2. Reflect para operaciones de bajo nivel
  3. Definición de propiedades con Object.defineProperty
  4. Descriptores de propiedad (get, set, enumerable, configurable)
  5. Object.getPrototypeOf y Object.setPrototypeOf
  6. Object.freeze y Object.seal
  7. Patrón de interceptores y validación dinámica
  8. Generación dinámica de clases y funciones
  9. Evaluación dinámica de código (riesgos de eval)
  10. Serialización y reconstrucción dinámica de objetos
  11. Decoradores (propuesta TC39) como metaprogramación declarativa
  12. Metadatos de tipos en runtime (emulación con reflect-metadata)
  13. Inspección de stack trace y Error.captureStackTrace
  14. Patrones AOP (aspect-oriented programming) con Proxies
  15. Instrumentación dinámica para profiling
5. Gestión de Recursos y Ciclo de Vida
  1. try/finally para liberar recursos
  2. Cancelación con AbortController
  3. Control manual de conexiones abiertas
  4. Streams y close/destroy
  5. Suscripciones a eventos y removeEventListener
  6. Limpieza de setInterval y setTimeout
  7. Manejadores de cierre de proceso en Node (process.on("exit"))
  8. Gestión de sockets abiertos
  9. Liberación de handles en tests
  10. Patrones de “destructor” manual en JS
  11. Patrones using y Symbol.dispose (propuesta)
  12. Control explícito de sesiones y tokens
  13. Recursos del DOM (observadores, listeners)
  14. Evitar fugas de listeners en SPAs
  15. Limpieza de workers inactivos
6. Monitoreo, Métricas y Telemetría
  1. console.time y console.count
  2. Performance API en navegador
  3. Node perf_hooks para medición
  4. Recolección de métricas de latencia
  5. Recolección de métricas de throughput
  6. Métricas de uso de memoria
  7. Métricas de GC y pausas
  8. Logs estructurados con IDs de correlación
  9. Trazas distribuidas con headers de tracing
  10. Exportación de métricas a sistemas externos
  11. Alertas automáticas en producción
  12. Health checks y endpoints /health
  13. Rate limiting y mecanismos antiabuso
  14. Auditoría de acciones del usuario
  15. Observabilidad en entornos serverless / edge
7. Recolección de Basura y Memoria
  1. Modelo de memoria administrada en JS
  2. Recolección de basura generacional
  3. Referencias fuertes vs débiles
  4. WeakMap y WeakSet
  5. WeakRef y FinalizationRegistry
  6. Fugas de memoria por referencias colgantes
  7. Fugas de memoria en closures
  8. Fugas de memoria en listeners no removidos
  9. Fragmentación de heap
  10. Trazas de heap en DevTools
  11. Monitoreo de uso de memoria en Node
  12. Límites de memoria en entornos serverless
  13. Impacto de objetos gigantes y arrays densos
  14. Uso de estructuras inmutables para evitar duplicados grandes
  15. Pausas de GC y rendimiento en tiempo real
8. Interoperabilidad con Bajo Nivel y WebAssembly
  1. WebAssembly en el navegador
  2. Cargar módulos WebAssembly desde JavaScript
  3. Tipos numéricos de bajo nivel en WebAssembly
  4. Compartir memoria entre WebAssembly y JS
  5. Llamar funciones WebAssembly desde JS
  6. Llamar funciones JS desde WebAssembly
  7. Uso de WebAssembly para cómputo intensivo
  8. Integración con librerías compiladas (C/C++/Rust)
  9. WebAssembly en Node
  10. Conversión de buffers binarios para FFI
  11. Overhead de cruce de frontera JS ↔ WASM
  12. Control de tiempo real y latencia baja
  13. Seguridad y sandboxing de WebAssembly
  14. Reutilización de lógica en cliente y servidor vía WASM
  15. Limitaciones de WebAssembly frente a JS puro
Implementación y Distribución
1. Herramientas de Entorno y Configuración
  1. tsconfig.json y opciones del compilador
  2. target y nivel de ECMAScript emitido
  3. module y formato de salida (ESNext, CommonJS)
  4. moduleResolution y resolución de paths
  5. strict y modo estricto
  6. noImplicitAny
  7. strictNullChecks
  8. esModuleInterop y compatibilidad con CommonJS
  9. skipLibCheck y rendimiento de compilación
  10. declaration y generación de .d.ts
  11. sourceMap para depuración
  12. outDir y rootDir
  13. Configuración por proyecto y references
  14. Proyectos incrementales (composite)
  15. paths y alias internos de importación
2. Motores e Implementaciones de JavaScript
  1. V8 (Chrome, Node)
  2. SpiderMonkey (Firefox)
  3. JavaScriptCore (Safari)
  4. Chakra (histórico)
  5. Node.js como runtime en servidor
  6. Deno como runtime seguro y TS-first
  7. Bun como runtime y bundler integrado
  8. Cloudflare Workers / runtimes edge
  9. Service Workers y ejecución offline en navegador
  10. Motores en entornos embebidos (Electron)
  11. JS en entornos móviles híbridos
  12. Diferencias de API entre runtimes
  13. globalThis como abstracción común
  14. Límite de memoria y CPU en entornos edge/serverless
  15. Compatibilidad con módulos ES nativos
3. Empaquetado, Build y Publicación
  1. webpack y empaquetado tradicional
  2. rollup para librerías
  3. esbuild y builds ultrarrápidos
  4. vite y desarrollo con HMR
  5. Transpilación con tsc
  6. Transpilación con Babel
  7. Tree-shaking y eliminación de código muerto
  8. Code splitting dinámico
  9. Generación de bundles múltiples (cjs, esm, iife)
  10. Minificación y ofuscación
  11. Generación de tipos .d.ts para consumidores TS
  12. Publicación en npm (npm publish)
  13. Versionado semántico (major.minor.patch)
  14. Changelogs y releases automatizados
  15. Publicación de paquetes privados internos
4. Aplicaciones de Línea de Comando (CLI)
  1. Scripts ejecutables con Node (#!/usr/bin/env node)
  2. Commander.js para parseo de argumentos
  3. yargs para CLI declarativas
  4. process.argv y parseo manual
  5. Colores y formato en consola (chalk)
  6. Spinners y progreso visual en CLI
  7. Entrada interactiva (inquirer)
  8. Salida estructurada en JSON
  9. Logs y niveles verbosos (-v, --debug)
  10. Errores amigables en CLI
  11. Empaquetado de CLI en un solo archivo
  12. Distribución como paquete npm global
  13. Versionado y flags --version
  14. Comandos compuestos y subcomandos
  15. Autocompletado de shell (bash/zsh/fish)
5. Aplicaciones Web y UI
  1. DOM y manipulación directa
  2. React y componentes funcionales
  3. JSX y TSX
  4. Hooks y estado local
  5. Estado global (Redux, Zustand)
  6. Context API
  7. Next.js y renderizado del lado del servidor (SSR)
  8. Vue con composición y tipado
  9. Svelte y bindings reactivos
  10. Web Components y customElements.define
  11. Shadow DOM y encapsulación de estilos
  12. CSS Modules / CSS-in-JS
  13. Accesibilidad (a11y)
  14. Persistencia de estado en localStorage
  15. Comunicación con APIs desde la UI
6. Aplicaciones Móviles, Escritorio y Juegos
  1. React Native
  2. Expo y flujo móvil con TypeScript
  3. Capacitor / Ionic para apps híbridas
  4. Electron para escritorio
  5. Tauri y runtimes ligeros
  6. PWAs (Progressive Web Apps)
  7. Service Workers y caché offline
  8. Notificaciones push
  9. Acceso a hardware (sensores, cámara, micrófono)
  10. APIs de archivos locales en escritorio
  11. Motores gráficos 2D/3D (Pixi.js, Three.js)
  12. Animaciones con requestAnimationFrame
  13. Optimización de render en canvas/WebGL
  14. Sincronización de estado en tiempo real multijugador
  15. Distribución en tiendas (App Store / Play Store) vía wrappers
7. Internacionalización (i18n) y Localización (l10n)
  1. API Intl
  2. Formato de números y monedas
  3. Formato de fechas y horarios
  4. Pluralización de mensajes
  5. Detección de locale del usuario
  6. Carga dinámica de mensajes traducidos
  7. Separación de traducciones por módulo
  8. Herramientas como i18next
  9. ICU MessageFormat
  10. Manejo de RTL (right-to-left)
  11. Zoned time y horario local
  12. Sensibilidad cultural en contenido
  13. Selección dinámica de fuentes y tipografías
  14. Traducción en build vs runtime
  15. Estrategias de fallback de idioma
8. DevOps, Entrega y Despliegue
  1. Scripts de build en package.json
  2. Pipelines CI/CD
  3. Pruebas automáticas en cada commit
  4. Lint y type-check en CI
  5. Empaquetado para producción
  6. Despliegue en servidores Node tradicionales
  7. Despliegue serverless (AWS Lambda, Vercel Functions)
  8. Despliegue edge (Cloudflare Workers)
  9. Contenedores Docker para Node
  10. Health checks y monitoreo post-deploy
  11. Rollbacks y despliegues azules/verdes
  12. Feature flags y rollout gradual
  13. Versionado de APIs públicas
  14. Documentación de endpoints y contratos
  15. Observabilidad continua en producción
Internos
1. Compilador de TypeScript y Proceso de Transpilación
  1. Análisis léxico y parser
  2. Creación del AST (árbol de sintaxis abstracta)
  3. Chequeo de tipos estático
  4. Inferencia de tipos
  5. Ampliación y reducción de uniones
  6. Emisión (emit) de JavaScript
  7. Generación de d.ts para tipos públicos
  8. Sourcemaps para depuración
  9. Proyectos incrementales y tsbuildinfo
  10. Referencias a proyectos (project references)
  11. Diferencias entre tsc y Babel para TS
  12. Limitaciones del chequeo de tipos en tiempo de compilación
  13. Eliminación de tipos y anotaciones en el JS emitido
  14. Transformaciones personalizadas del compilador
  15. Integración del Language Service en el editor
2. Modelo de Ejecución de JavaScript
  1. Call stack
  2. Contextos de ejecución
  3. Ámbito léxico y closures
  4. Hoisting de variables y funciones
  5. Resolución de this
  6. Strict mode ("use strict")
  7. Event Loop y cola de tareas
  8. Microtareas (Promise.then)
  9. Macrotareas (setTimeout, I/O)
  10. Repaint / reflow del navegador
  11. Prioridades de tareas en el navegador
  12. Bloqueo del main thread
  13. Interacción entre JS y render de la UI
  14. Rechazos no manejados de Promesas
  15. Módulos ES y carga dinámica en runtime
3. Modelo de Datos y Prototipos
  1. Objetos y prototipos
  2. [[Prototype]] y __proto__
  3. Cadena de prototipos
  4. Herencia basada en prototipos
  5. Clases como azúcar sintáctico sobre prototipos
  6. Descriptores de propiedad
  7. Enumerabilidad e iteración de llaves
  8. Object.keys, Object.values, Object.entries
  9. Object.assign y mezcla de objetos
  10. Sellado y congelamiento de objetos
  11. Inmutabilidad superficial vs profunda
  12. Comparación de objetos por referencia
  13. Serialización con JSON.stringify
  14. Limitaciones de JSON.stringify (funciones, undefined, Symbol)
  15. Clonación estructurada (structuredClone)
4. Optimizaciones del Motor JavaScript
  1. JIT (Just-In-Time compilation)
  2. Inline caching
  3. Hidden classes
  4. Escape analysis
  5. Optimización de funciones calientes
  6. Deoptimización cuando cambian los tipos
  7. Representación interna de números (double, SMI)
  8. Recolección generacional de basura
  9. Inlining de funciones
  10. Eliminación de bounds checks en arrays
  11. Optimización de bucles apretados
  12. Penalización por megamorphic call sites
  13. Estructuras densas vs dispersas en arrays
  14. Impacto de delete en arrays
  15. Costo de capturar closures con muchas variables
5. Interoperabilidad Nativa y FFI
  1. Addons nativos en Node (N-API)
  2. Interfaz C/C++ para módulos de alto rendimiento
  3. Compilación de addons para múltiples plataformas
  4. Gestión de memoria manual en addons
  5. Paso de buffers binarios entre JS y C++
  6. Seguridad y aislamiento al ejecutar código nativo
  7. Puentes con Rust (Neon, napi-rs)
  8. Puentes con Go (gobridge)
  9. Llamadas a librerías del sistema desde Node
  10. Consideraciones de portabilidad en binarios precompilados
  11. Versionado de ABI y compatibilidad
  12. Costos de cruce entre JS y nativo
  13. Exponer bindings tipados a TypeScript
  14. Depuración de código nativo integrado
  15. Distribución de módulos con binarios preconstruidos
6. WebAssembly y Runtimes Aislados
  1. Compilación de código C/C++/Rust a WebAssembly
  2. Carga de módulos WASM en navegador
  3. Carga de módulos WASM en Node
  4. Memoria lineal compartida con WASM
  5. Paso de strings y arrays entre JS y WASM
  6. Ejecución de lógica crítica en WASM
  7. Aceleración de cómputo matemático
  8. WASM y sandboxing de seguridad
  9. Límites de llamadas frecuentes JS↔WASM
  10. Uso de WASI (interfaz de sistema para WASM)
  11. Ejecución en entornos serverless edge
  12. Reutilización de librerías nativas vía WASM
  13. Perfilado de rendimiento en WASM
  14. Integración con Web Workers para aislamiento
  15. Futuro de WASM en aplicaciones web complejas
7. Estándares, Propuestas y Futuro del Lenguaje
  1. Proceso de propuesta TC39 (stages 0–4)
  2. Nuevas sintaxis del lenguaje
  3. Nuevas APIs estándar del runtime
  4. Decoradores estandarizados
  5. Records y Tuples inmutables (propuestas)
  6. Patrones de coincidencia estructural (pattern matching)
  7. Tipos sellados y exhaustividad
  8. Registros inmutables para datos seguros
  9. Tipos para excepciones y unknown seguro
  10. Campos privados # en clases
  11. Módulos nativos en el navegador sin bundler
  12. Evolución de import dinámico y lazy
  13. Nuevos primitivos de sincronización
  14. APIs criptográficas más ricas en WebCrypto
  15. Estandarización de APIs de streaming y backpressure
8. Límites y Buenas Prácticas de Arquitectura
  1. Separación entre lógica de dominio y capas de infraestructura
  2. Evitar acoplamiento a frameworks
  3. Diseñar para testabilidad
  4. Manejo centralizado de configuración
  5. Manejo centralizado de errores
  6. Límite claro entre cliente y servidor
  7. Reutilización de tipos entre frontend y backend
  8. Versionado de contratos de API
  9. Estrategias de backward compatibility
  10. Limpieza de código muerto y flags experimentales
  11. Migraciones de datos controladas
  12. Monitoreo desde el inicio del proyecto
  13. Hardening de seguridad como requisito base
  14. Automatización de calidad en CI/CD
  15. Cultura de documentación viva y mantenible

3 - Rust

Introduccion
1. Historia de Rust
  1. Orígenes en Mozilla Research (Graydon Hoare, 2006–2010)
  2. Evolución de prototipos tempranos a Rust 0.x
  3. Lanzamiento de Rust 1.0 (2015)
  4. Consolidación de la estabilidad del lenguaje y del compilador (rustc)
  5. Filosofía de seguridad de memoria sin garbage collector
  6. Filosofía de concurrencia sin miedo (“fearless concurrency”)
  7. Influencia de Cyclone, ML, C++ y el ecosistema de sistemas
  8. Participación comunitaria y apertura del desarrollo
  9. Migración desde la sintaxis antigua (~, @, &) hacia el modelo actual de ownership
  10. Adopción industrial en sistemas embebidos, backend de alto rendimiento y navegadores
  11. Rol de Servo y el motor de renderizado experimental
  12. Influencia de Rust en otros lenguajes de sistemas
2. Ediciones de Rust y Compatibilidad
  1. Edición 2015
  2. Edición 2018
  3. Edición 2021
  4. Planificación de ediciones futuras (por ejemplo 2024)
  5. Ediciones vs versiones del compilador (rustc)
  6. Estabilidad del lenguaje y promesa de no romper código estable
  7. Estabilidad de la librería estándar (std) y API pública
  8. Uso de lints para migración entre ediciones
  9. Modo cargo fix --edition y migración asistida
  10. Compatibilidad cruzada entre crates de distintas ediciones
  11. Feature flags experimentales en nightly
  12. #![feature(...)] y límites de estabilidad
  13. Cambios de sintaxis entre ediciones
  14. Cambios en el sistema de módulos entre ediciones
  15. Cambios en async/await y try operator entre ediciones
  16. Cambios en paths relativos y absoluta vs crate::
3. Instalación de Rust
  1. rustup como herramienta oficial de instalación
  2. Canales stable, beta, nightly
  3. Instalación en Windows (MSVC vs GNU toolchain)
  4. Instalación en macOS (homebrew, pkg oficial)
  5. Instalación en Linux (gestores de paquetes vs rustup)
  6. Añadir componentes (rustfmt, clippy)
  7. rustup component add
  8. Targets de compilación cruzada (rustup target add)
  9. Configuración del linker para cross-compiling
  10. Toolchains específicos por proyecto (rust-toolchain.toml)
  11. Versiones fijadas para CI
  12. Perfiles corporativos y espejos internos de toolchain
  13. Instalar cargo en entornos mínimos
  14. Modo offline y caché local de crates
4. Ejecución de Código Rust y Flujo de Trabajo
  1. rustc archivo.rs
  2. cargo new
  3. cargo init
  4. cargo build
  5. cargo run
  6. cargo check
  7. cargo test básico
  8. cargo bench básico
  9. cargo doc --open
  10. Flags comunes de compilación (--release, --verbose)
  11. Perfiles dev y release
  12. Nivel de optimización (-C opt-level)
  13. RUSTFLAGS y configuración avanzada del compilador
  14. cargo clippy y análisis estático
  15. REPLs experimentales (evcxr)
  16. Scripts rápidos y prototipos con cargo-script
  17. Uso del Playground de Rust
  18. Redirección de stdin/stdout/stderr en binarios Rust
5. IDEs y Editores de Código
  1. rust-analyzer y protocolo LSP
  2. VS Code con rust-analyzer
  3. IntelliJ Rust / CLion
  4. Vim / Neovim con LSP
  5. Emacs (lsp-mode, eglot)
  6. Autoformato con rustfmt
  7. Sugerencias y acciones rápidas de clippy
  8. Navegación por definiciones y go to definition
  9. Renombrado simbólico seguro (rename refactor)
  10. Depuración con lldb
  11. Depuración con gdb
  12. Mapas de memoria y stepping a nivel de instrucción
  13. Integración con CodeLLDB en VS Code
  14. Integración con herramientas de profiling
  15. Soporte de test integrado en el IDE
  16. Integración con cargo watch para recarga continua
6. Gestión de Dependencias y Entornos
  1. cargo como build system y gestor de dependencias
  2. Cargo.toml
  3. Cargo.lock
  4. Versionado semántico en dependencias ("1.2", "^1.2", "~1.2")
  5. Dependencias opcionales (optional = true)
  6. Features activables por crate
  7. Workspaces de Cargo
  8. Herencia de workspace en Cargo.toml
  9. Dependencias locales (path =)
  10. Dependencias desde Git
  11. Overrides de versiones ([patch])
  12. Mirrors y registries privados
  13. Vendorización de crates (cargo vendor)
  14. Caché local de compilación incremental
  15. Reproducibilidad entre entornos
  16. Compilación determinista para entrega binaria
  17. Bloqueo de versiones en CI
  18. Auditoría de dependencias (cargo audit)
7. Distribución de Crates
  1. Crates binarios
  2. Crates de librería
  3. Crates proc-macro
  4. Crates no_std
  5. Crates FFI (cdylib, staticlib)
  6. Publicación en crates.io
  7. cargo publish
  8. cargo yank
  9. Versionado semántico responsable
  10. Metadatos obligatorios en Cargo.toml
  11. Licencia y license/license-file
  12. readme y documentación pública
  13. Keywords y categorías
  14. exclude / include
  15. Seguridad de la cadena de suministro
  16. Firmas y verificación de integridad
  17. Auditoría de licencias (cargo deny)
  18. Revisión por pares y mantenimiento comunitario
8. Herramientas Complementarias
  1. rustfmt (formato)
  2. clippy (linter)
  3. cargo doc (documentación)
  4. cargo test (testing)
  5. cargo bench (benchmarking)
  6. cargo profile / perfiles de rendimiento
  7. cargo tree (árbol de dependencias)
  8. cargo metadata
  9. cargo install
  10. cargo uninstall
  11. cargo run --release
  12. cargo build --target
  13. cargo fix
  14. cargo fmt
  15. cargo clippy --fix
  16. Integración con CI/CD
  17. Integración con contenedores
  18. Integración con sistemas de empaquetado nativo
  19. Reproducibilidad en builds herméticos
  20. Automatización con Makefile y just
Fundamentos
1. Tipos de Datos Básicos
  1. Variables y let
    1. Declaración con inferencia de tipo
    2. Anotación explícita de tipo
    3. Mutabilidad con mut
    4. Sombras (shadowing) y redeclaración
    5. Variables temporales y scope de bloque
    6. const para constantes en tiempo de compilación
    7. static y static mut
  2. Booleanos (bool)
  3. Tipos numéricos escalares
    1. Enteros con signo (i8, i16, i32, i64, i128, isize)
    2. Enteros sin signo (u8, u16, u32, u64, u128, usize)
    3. Flotantes (f32, f64)
    4. Literales numéricos con separadores _
    5. Conversión entre anchos de entero
    6. Casting con as
    7. Operaciones “checked”, “wrapping”, “saturating”
    8. Módulo std::num
    9. Rangos y límites (MIN, MAX)
  4. Caracteres y texto
    1. char como escalar Unicode
    2. Literales de carácter
    3. &str (slice de string inmutable)
    4. String (buffer dinámico UTF-8)
    5. Conversión entre &str y String
    6. String::from y .to_string()
    7. Indexación y slicing seguro en UTF-8
    8. Formato con macros (format!, println!)
    9. Cow<'a, str>
    10. OsStr y OsString
    11. Path y PathBuf
  5. Tuplas
    1. Tuplas con nombre posicional
    2. Tuple structs
    3. Desestructuración de tuplas
    4. Retorno múltiple con tuplas
    5. Tupla vacía ()
    6. () como tipo unit
  6. Arrays y slices
    1. Arrays fijos [T; N]
    2. Slices &[T]
    3. Slices mutables &mut [T]
    4. Indexación segura y get()
    5. Recortes (split_at, chunks, windows)
    6. Slices de bytes (&[u8])
    7. Conversión de arrays a slices
  7. Propiedad y move
    1. Propiedad exclusiva de valores
    2. Movimiento vs copia (Copy)
    3. Clone explícito
    4. Tipos Copy
    5. Tipos que no son Copy
    6. Transferencia de propiedad a funciones
    7. Retorno de propiedad desde funciones
  8. Préstamos y referencias
    1. Referencias inmutables &T
    2. Referencias mutables &mut T
    3. Reglas de aliasing único para mutables
    4. Duración del préstamo (lifetime implícito)
    5. Prestando vs moviendo
    6. Mutabilidad interior
    7. Reglas de borrow checker
  9. Lifetimes
    1. Parámetros de lifetime explícitos ('a)
    2. Elision de lifetimes
    3. Relaciones de subvida ('a: 'b)
    4. Lifetimes en referencias de retorno
    5. Lifetimes en structs
    6. Lifetimes en métodos impl
    7. 'static
    8. Lifetimes en closures
  10. Enumeraciones (enum)
  11. Variantes sin datos
  12. Variantes tipo tupla
  13. Variantes tipo struct
  14. Patrones exhaustivos con match
  15. Option<T>
  16. Result<T, E>
  17. Ordering
  18. Never type (!)
  19. Structs
  20. Structs con campos nombrados
  21. Tuple structs
  22. Unit structs
  23. pub y visibilidad de campos
  24. Inicialización con sintaxis { campo: valor }
  25. Actualización de struct (..otro)
  26. Propiedad de campos y movimientos parciales
  27. Empaquetar datos y semántica de valor
  28. Traits básicos
  29. Copy
  30. Clone
  31. Debug
  32. Display
  33. Default
  34. PartialEq / Eq
  35. PartialOrd / Ord
  36. Hash
  37. Send
  38. Sync
  39. Unpin
  40. Sized
  41. Conversión y coerción
  42. From / Into
  43. TryFrom / TryInto
  44. AsRef / AsMut
  45. Borrow
  46. Deref / DerefMut
  47. Auto-deref en llamadas a métodos
  48. Conversión numérica con as
  49. Conversión de slices entre tipos compatibles
  50. Pattern matching de destructuración
  51. let + patrones
  52. if let
  53. while let
  54. Patrones en parámetros de función
  55. Patrones en match
  56. Patrones anidados en structs y enums
  57. Patrones con guardas (if)
  58. Patrones con @
  59. Patrones con _
  60. Patrones de rango (..=)
2. Operadores
  1. Operadores aritméticos (+, -, *, /, %)
  2. Operadores de asignación compuesta (+=, -=, *=, /=, %=)
  3. Operadores bit a bit (&, |, ^, !, <<, >>)
  4. Comparación (==, !=, <, >, <=, >=)
  5. Operadores lógicos (&&, ||, !)
  6. Precedencia de operadores
  7. Evaluación corta (short-circuit) en && y ||
  8. Operador de rango (.., ..=)
  9. Desreferenciación (*)
  10. Indexación ([])
  11. ? para propagación de errores
  12. as para casting explícito
  13. Operador ref en patrones
  14. box (histórico) y Box::new
  15. .. en patrones de struct
  16. .. en patrones de tuplas y enums
  17. & y &mut en patrones de referencia
  18. | en patrones alternativos en match
  19. @ en patrones con binding
  20. .. en ranges de iteración
3. Control de Flujo
  1. if
  2. else if
  3. else
  4. if como expresión
  5. match
  6. match exhaustivo
  7. match con guardas (if cond)
  8. match con patrones anidados
  9. if let
  10. while
  11. while let
  12. loop
  13. for
  14. Rango en for
  15. break
  16. continue
  17. return
  18. Etiquetas de bucle ('label:)
  19. break 'label
  20. continue 'label
  21. let else para validación temprana
  22. try blocks experimentales
  23. panic! como corte de control
  24. unreachable! y todo!
  25. assert! y control en test
4. Funciones
  1. Definición de funciones con fn
  2. Parámetros con tipo explícito
  3. Retorno con ->
  4. Retorno implícito sin return
  5. Funciones libres vs métodos asociados
  6. Métodos en impl
  7. Métodos estáticos (fn new())
  8. Referencias &self
  9. Referencias &mut self
  10. Funciones genéricas
  11. Trait bounds en firmas (where)
  12. Lifetimes explícitos en firmas
  13. Funciones const fn
  14. Funciones unsafe fn
  15. Funciones extern "C"
  16. Funciones inline (#[inline])
  17. Atributos en funciones (#[must_use], #[cold], #[inline(always)])
  18. Punteros a función (fn vs Fn traits)
  19. macro_rules! vs fn
  20. Visibilidad pub en funciones
5. Closures
  1. Sintaxis |args| expr
  2. move closures
  3. Inferencia de tipos en closures
  4. Captura por referencia
  5. Captura por mutable referencia
  6. Captura por movimiento
  7. Traits Fn, FnMut, FnOnce
  8. Conversión de closures a punteros de función
  9. Almacenamiento de closures en Box<dyn Fn>
  10. Lifetimes en closures
  11. Uso de closures en iteradores
  12. Uso de closures en APIs async
  13. Cierres como callbacks en FFI seguro
  14. impl Fn en parámetros
  15. impl FnOnce para consumo de recursos
6. Manejo de Errores
  1. Result<T, E>
  2. Option<T>
  3. Operador ?
  4. unwrap
  5. expect
  6. ok_or / ok_or_else
  7. map_err
  8. and_then
  9. Definir tipos de error propios
  10. Trait std::error::Error
  11. Errores encadenados
  12. thiserror (crates de error derivado)
  13. Manejo de errores en main
  14. Devolución de Result desde main
  15. panic!
  16. Recuperación después de panic con catch_unwind
  17. assert!, assert_eq!, debug_assert!
  18. todo!
  19. unimplemented!
  20. unreachable!
7. Prelude y Librería Estándar
  1. std::prelude
  2. Carga automática del prelude
  3. Tipos fundamentales en el prelude
  4. Traits fundamentales en el prelude
  5. std vs core
  6. alloc en entornos no_std
  7. use std::... y rutas absolutas
  8. pub use para reexportar APIs
  9. std::io
  10. std::fs
  11. std::env
  12. std::path
  13. std::time
  14. std::thread
  15. std::sync
  16. std::net
  17. std::process
  18. std::mem
  19. std::ptr
  20. std::slice
  21. std::str
  22. std::string
  23. std::vec
8. Módulos y Visibilidad
  1. mod
  2. Archivos y submódulos
  3. Jerarquía de módulos (crate, super, self)
  4. pub
  5. pub(crate)
  6. pub(super)
  7. pub(in path)
  8. use
  9. use as
  10. Reexport con pub use
  11. Separación binario / librería (src/main.rs, src/lib.rs)
  12. Árbol de módulos y layout de carpetas
  13. Módulos privados internos
  14. Módulos cfg condicionales
  15. #[path = "file.rs"]
  16. extern crate (histórico)
  17. crate:: paths absolutos
  18. super:: paths relativos
  19. Módulos inline { ... }
  20. Tests integrados en módulos (#[cfg(test)])
9. Atributos y Macros Básicas
  1. Atributos en ítems (#[derive], #[inline], #[allow])
  2. Atributos en módulos (#![allow], #![deny])
  3. Atributos de lint (#[warn(clippy::...)])
  4. Macros declarativas macro_rules!
  5. Macros de formato (println!, eprintln!, format!)
  6. Macros de colección (vec!, vecDeque! en crates externos)
  7. Macros de aserción (assert!, debug_assert!)
  8. Macros de error (panic!)
  9. Macros condicionales (cfg!)
  10. Macros de test (#[test])
  11. Macros de derivación automática (#[derive(Clone, Debug, ...)])
10. Atributos de Compilación Condicional
11. #[cfg(target_os = "linux")]
12. #[cfg(target_arch = "x86_64")]
13. #[cfg(feature = "foo")]
14. #[cfg(test)]
15. #[cfg(debug_assertions)]
16. #[cfg_attr(...)]
17. cfg_if! (macro de conveniencia)
18. Builds multiplataforma con cfg
19. Código específico de arquitectura
20. Desactivación de partes inseguras en WASM
21. Estándares de Estilo
22. Formato con rustfmt
23. Organización de use
24. Nomenclatura de tipos (PascalCase)
25. Nomenclatura de variables y funciones (snake_case)
26. Constantes (SCREAMING_SNAKE_CASE)
27. División en módulos pequeños
28. Comentarios /// para docs públicas
29. Comentarios //! a nivel de crate
30. Comentarios de implementación //
31. #[allow] vs #[deny] para lints
32. Políticas internas de clippy
33. Reglas de API públicas estables
34. Visibilidad mínima (pub vs pub(crate))
35. Convenciones de Proyecto
36. src/main.rs
37. src/lib.rs
38. src/bin/*.rs
39. Cargo.toml
40. Cargo.lock
41. README.md
42. LICENSE
43. rust-toolchain.toml
44. benches/
45. examples/
46. tests/
47. build.rs
48. target/
49. Módulos internos mod.rs vs foo.rs
50. Estructura por dominio
51. Estructura por capas (core, infra, api)
52. Reexportar APIs en lib.rs
53. #[deny(missing_docs)]
54. Versionado del crate
55. Features opcionales y default-features = false
Estructuras y manipulación de datos
1. Colecciones Estándar
  1. Vec<T>
  2. Creación y vec![]
  3. Push / pop
  4. Indexación y .get()
  5. Iteración mutable e inmutable
  6. Reservar capacidad (with_capacity, reserve)
  7. insert, remove
  8. retain
  9. sort, sort_by, sort_unstable
  10. dedup
  11. drain
  12. Conversión Vec<T> ↔ slice
  13. VecDeque<T>
  14. VecDeque push_front / push_back
  15. LinkedList<T>
  16. BinaryHeap<T>
  17. HashMap<K, V>
  18. BTreeMap<K, V>
  19. HashSet<T>
  20. BTreeSet<T>
  21. IndexMap, IndexSet (orden estable, crates externos)
  22. SmallVec, ArrayVec (almacenamiento en stack)
  23. Cow<T>
  24. Range
  25. Option<T> como colección parcial
  26. Result<T,E> como flujo condicional
  27. APIs de iteradores en colecciones
  28. String y Vec<u8>
  29. Box<[T]>
  30. Rc<[T]> y Arc<[T]>
2. Pilas y Colas
  1. Vec<T> como pila LIFO
  2. VecDeque<T> como cola FIFO
  3. BinaryHeap<T> como cola de prioridad
  4. Múltiples productores / múltiples consumidores usando canales
  5. Estructuras lock-free con crossbeam (crates externos)
  6. Colas concurrentes en tokio::sync
  7. std::sync::mpsc
  8. Orden de mensajes garantizado
  9. try_recv / recv_timeout
  10. Backpressure en colas async
3. Slicing y Vistas
  1. Slices &[T]
  2. Slices mutables &mut [T]
  3. Vistas parciales (split_at, split)
  4. Ventanas (windows)
  5. Chunks (chunks, chunks_exact)
  6. array_chunks y vistas fijas
  7. as_slice / as_mut_slice
  8. str como slice de u8 UTF-8
  9. Slices crudas (*const T, *mut T)
  10. std::slice::from_raw_parts
  11. Reglas de seguridad en slices no verificados
4. Manipulación de Strings
  1. String
  2. &str
  3. Concatenación con push_str
  4. Concatenación con +
  5. Formato con format!
  6. Interpolación con println!
  7. Iteración por bytes
  8. Iteración por char
  9. Iteración por grapheme (crates externos)
  10. Substrings seguras por rango de bytes válidos
  11. Búsqueda (find, contains)
  12. Reemplazo (replace)
  13. Divisiones (split, split_whitespace)
  14. trim, trim_matches
  15. Conversión entre OsString, PathBuf, String
  16. to_string_lossy
  17. Normalización Unicode (crates externos)
  18. Cow<'_, str> para evitar copias
  19. Propiedad vs referencia en APIs de texto
  20. String::leak
5. Expresiones Regulares y Parsing
  1. Crate regex
  2. Expresiones regulares compiladas
  3. Búsquedas globales
  4. Capturas con grupos
  5. Reemplazo con patrones
  6. División por regex
  7. Expresiones regulares sin backtracking exponencial
  8. lazy_static / once_cell para regex globales
  9. regex-automata (crates especializadas)
  10. Parsing manual con chars()
  11. Parsing con nom
  12. Parsers basados en combinadores
  13. Parsing binario con nom / binrw
  14. serde para deserialización estructurada
6. Archivos y I/O
  1. std::fs::File
  2. File::open
  3. File::create
  4. Lectura síncrona (read_to_end, read_to_string)
  5. Escritura síncrona (write_all)
  6. BufReader
  7. BufWriter
  8. Lectura línea a línea (read_line)
  9. Iteración sobre líneas
  10. Permisos de archivo (set_permissions)
  11. metadata
  12. Directorios (read_dir)
  13. Creación y borrado de carpetas
  14. Renombrar y mover archivos
  15. Rutas (Path, PathBuf)
  16. std::env::current_dir
  17. tempfile (crates externos)
  18. Archivos mapeados en memoria (crates externos)
  19. I/O sin bloqueo en tokio::fs
  20. I/O con async-std::fs
7. Formatos de Datos
  1. JSON con serde_json
  2. TOML con toml
  3. YAML con serde_yaml
  4. CBOR / MessagePack (crates externos)
  5. Protobuf / FlatBuffers (crates externos)
  6. CSV con csv
  7. Lectura binaria con byteorder
  8. Escritura binaria con byteorder
  9. Manipulación de bits en buffers (bitvec)
  10. Serialización binaria con bincode
  11. serde derive (Serialize, Deserialize)
  12. Versionado de esquemas
  13. Migración de estructuras serializadas
  14. Validación de datos deserializados
8. Fechas y Tiempo
  1. std::time::Duration
  2. std::time::Instant
  3. std::time::SystemTime
  4. Diferencias de tiempo (duration_since)
  5. Timeouts en I/O
  6. Retrasos y sleep con std::thread::sleep
  7. Retrasos async con tokio::time::sleep
  8. Medición de rendimiento
  9. Perfiles de latencia
  10. Crate chrono (fecha/hora civil)
  11. Zonas horarias con chrono_tz
  12. Formateo de timestamps
  13. Parsing de timestamps
  14. Sincronización periódica y scheduling (crates externos)
  15. Timers async recurrentes (crates async)
9. Propiedad Compartida y Gestión de Recursos
  1. Box<T>
  2. Rc<T>
  3. Arc<T>
  4. Cell<T>
  5. RefCell<T>
  6. Mutex<T>
  7. RwLock<T>
  8. OnceCell<T>
  9. LazyLock<T>
  10. AtomicBool, AtomicUsize, etc.
  11. Conteo de referencias y ciclos
  12. Fugas deliberadas (Box::leak)
  13. Smart pointers específicos de librería
  14. RAII y liberación determinista con Drop
10. Iteradores
11. Iterator trait
12. .next()
13. for sobre iteradores
14. Adaptadores (map, filter, flat_map)
15. enumerate
16. zip
17. chain
18. rev
19. take, skip
20. collect
21. Colección en Vec
22. Colección en HashMap
23. Iteradores infinitos y std::iter::repeat
24. std::iter::from_fn
25. inspect
26. fold
27. try_fold
28. Propiedad vs referencia en iteradores
29. Iteradores que consumen (into_iter)
30. Iteradores prestados (iter, iter_mut)
31. Iteradores paralelos (rayon)
32. Iteradores async (Stream en ecosistema async)
33. Expresiones Funcionales y Pipelines
34. .map(...)
35. .filter(...)
36. .filter_map(...)
37. .find(...)
38. .any(...)
39. .all(...)
40. .position(...)
41. .fold(...)
42. .reduce(...)
43. .group_by(...) (crates externos)
44. Transformaciones in-place vs alocar nuevos Vec
45. Reutilización de buffers
46. Zero-copy usando slices
47. Evitar clonados innecesarios
48. Cow en pipelines de texto
49. Seguridad y Manejo Binario
50. std::mem::transmute (uso inseguro)
51. std::mem::replace
52. std::mem::take
53. MaybeUninit<T>
54. Layout de memoria (#[repr(C)], #[repr(packed)])
55. Alineación (align_of, align_to)
56. Lectura/escritura de bytes con byteorder
57. Endianness explícito
58. Acceso crudo con punteros (*const T, *mut T)
59. slice::from_raw_parts
60. ptr::copy_nonoverlapping
61. Control de aliasing en unsafe
62. Serialización binaria para FFI
63. Mapear estructuras Rust a C
Programación estructurada y modular
1. Programación Orientada a Datos y Traits
  1. Structs como tipos de datos centrales
  2. impl blocks
  3. Métodos asociados
  4. Métodos que consumen self
  5. Métodos que prestan &self
  6. Métodos que prestan &mut self
  7. Encapsulación con campos privados
  8. Getters explícitos
  9. Constructores estilo new()
  10. Builders encadenables
  11. Propiedades inmutables por defecto
  12. APIs seguras por tipo
  13. APIs que evitan estados inválidos
  14. Patrón tipo-sello (sealed traits en módulos privados)
  15. Patrón unsafe encapsulado en capa segura
2. Traits e Implementaciones
  1. Definición de trait
  2. Métodos requeridos
  3. Métodos con implementación por defecto
  4. Implementación de traits para tipos propios
  5. Implementación de traits externos para tipos propios (coherencia)
  6. Implementación de traits propios para tipos externos (orfan rule)
  7. Traits marcadores (Send, Sync, Unpin)
  8. Traits auto (auto trait)
  9. dyn Trait
  10. Trait objects (&dyn Trait, Box<dyn Trait>)
  11. Dispatch dinámico vs estático
  12. Traits genéricos
  13. Associated types en traits
  14. Supertraits
  15. where bounds complejos
  16. Implementaciones en impl<T> Trait for Tipo<T>
  17. Coerción de &T a &dyn Trait
  18. Objetos trait en interfaces plugin
  19. Objetos trait y Send + Sync
  20. Limitaciones de objetos trait (no Self en firma)
3. Encapsulación y Abstracción
  1. Visibilidad pub
  2. Visibilidad pub(crate)
  3. Visibilidad pub(super)
  4. Campos privados y módulos amigos
  5. Patrones con newtype
  6. Patrones de estado interno protegido
  7. API mínima segura
  8. Diseño de invariantes internas
  9. Tipos fantasma (phantom types)
  10. PhantomData<T>
  11. Tipos con lifetimes en la API pública
  12. Sellado de traits para evitar implementaciones externas
4. Composición vs Herencia
  1. Composición de structs
  2. Contención de datos (struct A { b: B })
  3. Delegación manual de métodos
  4. Deref para ergonomía de delegación
  5. Herencia ausente en el lenguaje base
  6. Subtipado vía traits
  7. Polimorfismo paramétrico (genéricos)
  8. Polimorfismo dinámico (trait objects)
  9. Patrones de tipo estado (state pattern)
  10. Patrones de builder tipado
  11. Patrones GADT a través de enums
  12. Patrones de “typestate programming”
5. Macros de Atributo y Derive
  1. #[derive(Debug)]
  2. #[derive(Clone)]
  3. #[derive(Copy)]
  4. #[derive(PartialEq, Eq)]
  5. #[derive(PartialOrd, Ord)]
  6. #[derive(Hash)]
  7. #[derive(Default)]
  8. #[derive(Serialize, Deserialize)]
  9. Atributos en campos (#[serde(rename = "...")])
  10. Procedural macros (proc-macro)
  11. #[test]
  12. #[bench] (inestable / crates externos)
  13. #[cfg(...)]
  14. #[inline]
  15. #[must_use]
  16. #[repr(C)]
  17. #[repr(packed)]
  18. #[non_exhaustive]
  19. #[deny(...)], #[allow(...)], #[warn(...)]
  20. Atributos específicos de plataforma
6. Módulos y Crates (avanzado)
  1. Crates binarios
  2. Crates librería
  3. Crates internos en un workspace
  4. Árbol de módulos público (lib.rs)
  5. Reexportar símbolos (pub use)
  6. Organización por dominio
  7. Organización por capa lógica
  8. Patrones prelude internos
  9. #[doc(hidden)]
  10. #[path]
  11. include!
  12. include_bytes!
  13. include_str!
  14. build.rs para generar código
  15. OUT_DIR y artefactos generados
  16. cfg(feature = "...")
  17. cfg(target_os = "...")
  18. cfg(test)
  19. Tests de integración en tests/
  20. Ejemplos en examples/
7. Logging
  1. Crate log
  2. Macros info!, warn!, error!, debug!, trace!
  3. Backends (env_logger, fern, tracing)
  4. Niveles de log
  5. Filtros de log por módulo
  6. Logging estructurado con tracing
  7. tracing::span y tracing::instrument
  8. Exportar logs a JSON
  9. Logs en aplicaciones CLI
  10. Logs en servicios async
  11. Logs en entornos no_std (semihosting / ITM)
  12. Rotación de logs (crates externos)
  13. Formato con timestamps
  14. Integración con observabilidad
  15. Uso de log en librerías reutilizables
8. Documentación
  1. Comentarios ///
  2. Comentarios //! a nivel de crate o módulo
  3. Ejemplos en documentación
  4. cargo doc
  5. cargo doc --open
  6. Documentación pública mínima
  7. #[doc(hidden)]
  8. #[deny(missing_docs)]
  9. Mostrar ejemplos que compilan
  10. Ejecución de ejemplos como tests doctest
  11. Documentar invariantes de seguridad
  12. Documentar unsafe
  13. Documentar lifetimes y ownership
  14. Documentar errores (Result)
  15. Políticas de versionado semántico en docs
  16. Guías de “cómo usar” en módulos raíz
  17. Ejemplos por feature flag
  18. Docs generadas para crates internos
  19. Publicación de docs en hosting estático
  20. Documentación interna vs externa
9. Testing
  1. #[test]
  2. cargo test
  3. Tests de unidad
  4. Tests de integración (tests/)
  5. Tests de documentación (doctests)
  6. assert!
  7. assert_eq!
  8. assert_ne!
  9. matches!
  10. should_panic
  11. Tests con Result<(), E>
  12. Tests async con runtimes (#[tokio::test])
  13. Tests parametrizados (macros de terceros)
  14. Fixtures simuladas manualmente
  15. tempfile para tests con disco
  16. Pruebas con proptest (property-based testing)
  17. Pruebas fuzzing (cargo fuzz)
  18. Pruebas de snapshot (insta)
  19. Pruebas de rendimiento (criterion)
  20. Cobertura de código (cargo tarpaulin)
  21. #[cfg(test)] secciones privadas de prueba
  22. Tests de concurrencia y race conditions
  23. Tests de integración multinodo / multi-hilo
  24. Mocking de dependencias (crates mockall, etc.)
  25. Simulación de redes con sockets falsos
  26. Tests deterministas de tiempo (fake_time)
  27. Tests con canal mpsc local
  28. Tests que validan Send + Sync
  29. Tests de unsafe correctness
  30. Validación de invariantes de memoria
10. Depuración
11. dbg! macro
12. println! debug
13. Debug derivado (#[derive(Debug)])
14. Revisar panic backtraces (RUST_BACKTRACE=1)
15. gdb
16. lldb
17. Depuración con VS Code (CodeLLDB)
18. Breakpoints en código Rust
19. Inspección de variables y lifetimes
20. Desensamblado de código generado
21. Inspección de ensamblador (rustc --emit asm)
22. Inspección de MIR (rustc --emit mir, nightly)
23. Inspección de LLVM IR (--emit llvm-ir)
24. Validación de alineación de punteros
25. Detección de UB potencial usando miri
26. Análisis con sanitizers (ASan, UBSan)
27. Chequeo de data races con ThreadSanitizer
28. Validación de límites con AddressSanitizer
29. Depuración de bloqueo mutuo (deadlock)
30. Depuración de rendimiento con perf
31. Flamegraphs
32. Inspección de heap con herramientas externas
33. Registros de tracing con tracing + tokio-console
34. Pruebas de estrés para reproducir condiciones de carrera
35. Auditoría manual de unsafe
Estructuras avanzadas y programación funcional
1. Programación Funcional y Estilo Declarativo
  1. Rust como lenguaje orientado a expresiones
  2. Expresiones en lugar de sentencias
  3. Cierres (|...| ...)
  4. Inmutabilidad preferida
  5. map, filter, fold
  6. flat_map
  7. Composición con iteradores
  8. Option como mónada de presencia/ausencia
  9. Result como mónada de éxito/error
  10. Encadenamiento con and_then
  11. Encadenamiento con map_err
  12. Control de flujo sin panic
  13. Early returns con ?
  14. if let como destructuración parcial
  15. match como eliminación exhaustiva de casos
  16. match anidado para composición de lógica
  17. let else para validaciones
  18. Uso de From / Into para componer transformaciones
  19. Tipos de dominio con invariantes fuertes
  20. Errores tipados en lugar de excepciones
2. Iteradores / Adaptadores / Streams
  1. Iterator trait
  2. Adaptadores estándar (map, filter, take, skip, enumerate)
  3. Adaptadores de flattening (flat_map, flatten)
  4. Adaptadores de búsqueda (find, position, rposition)
  5. Adaptadores de acumulación (fold, scan)
  6. Adaptadores de partición (partition, group_by con crates externos)
  7. Iteradores infinitos (repeat, successors)
  8. Iteradores sobre Result
  9. try_fold
  10. Paralelización con rayon::prelude::*
  11. Iteradores paralelos (par_iter, par_chunks)
  12. Recolección en Vec, HashMap, BTreeMap
  13. Iteradores mutables (iter_mut)
  14. Iteradores que consumen (into_iter)
  15. Iteradores sobre referencias (iter)
  16. Iteradores sobre slices (slice::Chunks, ChunksExact)
  17. Iteradores de archivos línea a línea
  18. Iteradores de sockets TCP
  19. Stream en async (futures::stream)
  20. Combinadores async (stream::map, stream::buffer_unordered)
3. Punteros Inteligentes y Mutabilidad Interior
  1. Box<T>
  2. Rc<T>
  3. Arc<T>
  4. Cell<T>
  5. RefCell<T>
  6. Mutex<T>
  7. RwLock<T>
  8. AtomicBool, AtomicUsize, AtomicPtr
  9. Arc<Mutex<T>>
  10. Arc<RwLock<T>>
  11. OnceCell<T>
  12. LazyLock<T>
  13. Weak<T>
  14. Ciclos con Rc y fuga de memoria lógica
  15. Romper ciclos con Weak
  16. Interior mutability patterns
  17. Single-thread vs multi-thread (Rc vs Arc)
  18. Envolturas seguras para FFI
  19. Gestión de recursos externos (file handles, sockets)
  20. RAII con Drop
4. Benchmarking y Perfilado
  1. cargo bench
  2. Crate criterion para benchmarks estadísticos
  3. Microbenchmarks de funciones puras
  4. Benchmarks con acceso a disco
  5. Benchmarks de red
  6. Perfiles de CPU con perf
  7. Perfiles de CPU con dtrace / eBPF
  8. Flamegraphs
  9. Análisis de asignaciones con valgrind / heaptrack
  10. Instrumentación manual con timestamps (Instant::now)
  11. Contadores internos de rendimiento
  12. Benchmarks de throughput vs latency
  13. Impacto de clone en hot paths
  14. Reducción de alloc en loops críticos
  15. Caches locales (HashMap interno)
  16. Inlining agresivo (#[inline(always)])
  17. Branch prediction hints (patrones de if likely usando crates externos)
  18. Mediciones en modo --release
  19. Evitar TLE bloqueando IO
  20. Ensamblador generado (rustc --emit asm)
5. Herramientas de Calidad de Código
  1. rustfmt para formateo automático
  2. clippy para lints
  3. cargo clippy --fix
  4. Lints de estilo
  5. Lints de rendimiento
  6. Lints de correctitud
  7. Lints de seguridad (uso de unsafe)
  8. Lints de complejidad
  9. Reglas internas de equipos (#![deny(warnings)])
  10. Revisiones de unsafe en PRs
  11. Auditorías de unsafe en librerías públicas
  12. Control de deuda técnica
  13. cargo deny para licencias y vulnerabilidades
  14. cargo audit para CVEs
  15. cargo udeps para dependencias no usadas
  16. cargo outdated para versiones antiguas
  17. cargo machete / cargo trim (limpieza de dependencias)
  18. Políticas de versión mínima soportada (MSRV)
  19. Análisis estático adicional con sanitizers
  20. Integración en CI (rustfmt --check, clippy -- -D warnings)
6. Seguridad de Memoria y Concurrencia
  1. Ausencia de null en tipos seguros (Option<T>)
  2. Ausencia de use after free bajo safe Rust
  3. Propiedad y lifetimes como contrato de seguridad
  4. Send
  5. Sync
  6. Send + Sync en tipos concurrentes
  7. Arc<Mutex<T>> para compartir estado
  8. RwLock para lecturas concurrentes
  9. Canales MPSC (std::sync::mpsc)
  10. Canales múltiples productores múltiples consumidores (crossbeam)
  11. Sincronización sin bloqueo (lock-free)
  12. Atomics (Ordering)
  13. Deadlocks y estrategias de evitación
  14. Condiciones de carrera y unsafe
  15. Problemas de memoria ABA en atomics
  16. Reglas de aliasing exclusivas
  17. &mut T como garantía de acceso exclusivo
  18. Verificación en tiempo de compilación vs runtime
  19. Compartir memoria en async sin Send (!Send futures)
  20. Minimizar unsafe en código concurrente
7. Sistema de Tipos Avanzado
  1. Genéricos (fn foo<T>(x: T))
  2. impl Trait en retorno
  3. impl Trait en parámetros
  4. where bounds complejos
  5. Traits con tipos asociados
  6. Traits con constantes asociadas
  7. Traits con lifetimes asociados
  8. Const generics (const N: usize)
  9. Arreglos genéricos [T; N] con const N
  10. PhantomData<T>
  11. Tipos marca (marker types)
  12. ! (never type)
  13. Tipos vacíos
  14. Tipos que no pueden construirse externamente
  15. enum no exhaustivos (#[non_exhaustive])
  16. Patrones sealed trait
  17. Coherencia de traits (orphan rules)
  18. Auto traits (Send, Sync)
  19. Sized y ?Sized
  20. Trait objects y dyn Trait
  21. Subtipado con lifetimes distintas
  22. Higher-Rank Trait Bounds (HRTB, for<'a>)
  23. Fn, FnMut, FnOnce
  24. Unpin
  25. Pin<P>
  26. Drop
  27. ManuallyDrop<T>
  28. MaybeUninit<T>
  29. Unsafe traits
  30. Límite entre safe Rust y unsafe Rust
Concurrencia, Async, Bajo Nivel
1. Async y Concurrencia
  1. Hilos (std::thread::spawn)
  2. JoinHandle
  3. move closures en threads
  4. Arc<T> para compartir datos entre hilos
  5. Mutex<T> para exclusión mutua
  6. RwLock<T> para lectura concurrente
  7. Barreras (Barrier)
  8. Canales std::sync::mpsc
  9. sync::mpsc::Sender / Receiver
  10. Canales crossbeam
  11. Canales tokio::sync::mpsc
  12. Semáforos async (tokio::sync::Semaphore)
  13. Condvar
  14. AtomicBool, AtomicUsize, etc.
  15. Fences de memoria (Ordering)
  16. Evitar data races con Send y Sync
  17. Send automático para la mayoría de tipos
  18. Tipos que no son Send
  19. Compartir file descriptors entre hilos
  20. Compartir conexiones de red
  21. Pools de hilos
  22. rayon para paralelismo de datos
  23. rayon::join
  24. par_iter
  25. Balanceo de carga de trabajo
  26. Uso de #[derive(Clone)] para handles ligeros
  27. Cancelación cooperativa entre hilos
  28. Pruebas de concurrencia
  29. Deadlock debugging
  30. Escalabilidad en CPU multinúcleo
2. Async/await
  1. async fn
  2. async { ... } bloques
  3. await
  4. Future trait (std::future::Future)
  5. Pin
  6. Unpin
  7. Box<dyn Future<Output = T> + Send>
  8. impl Future<Output = T>
  9. Ejecutores (tokio, async-std, smol)
  10. tokio::spawn
  11. tokio::select!
  12. Canales async (tokio::sync::mpsc)
  13. Mutex async (tokio::sync::Mutex)
  14. RwLock async
  15. Temporizadores async (tokio::time::sleep)
  16. Timeouts (tokio::time::timeout)
  17. Streams async (futures::stream::Stream)
  18. Backpressure en streams async
  19. Conexiones persistentes async
  20. I/O no bloqueante (tokio::net)
  21. Sockets TCP async
  22. Sockets UDP async
  23. WebSockets async
  24. Sincronización en single-threaded runtime
  25. Send y Sync en futures
  26. !Send futures y LocalSet
  27. task::yield_now y cooperación
  28. Cancelación de tareas async
  29. Reintentos con delays exponenciales
  30. Recolección de JoinHandle async
3. Redes y Comunicación
  1. std::net::TcpListener
  2. std::net::TcpStream
  3. std::net::UdpSocket
  4. Modo bloqueante
  5. Modo no bloqueante (set_nonblocking)
  6. Lectura/escritura con Read / Write
  7. Buffers ([u8])
  8. Gestión de errores de red (io::Result)
  9. Timeouts de socket
  10. Reintentos de conexión
  11. Serialización de mensajes (bincode, serde)
  12. Protocolos binarios personalizados
  13. HTTP cliente (reqwest)
  14. HTTP servidor (hyper, axum, warp, actix-web)
  15. WebSockets (crates externos)
  16. TLS (rustls)
  17. Certificados propios
  18. Protocolos binarios de baja latencia
  19. RPC (tonic gRPC)
  20. Streaming bidireccional
  21. Backpressure en servidores async
  22. Balanceo de carga
  23. Sharding de conexiones
  24. Pools de conexión
  25. Control de congestión a nivel de aplicación
  26. Telemetría de latencia y throughput
  27. Límite de tasa (rate limiting)
  28. Cortafuegos lógico a nivel de aplicación
  29. Instrumentación con tracing
  30. Testing de red con sockets falsos
4. Metaprogramación
  1. Macros declarativas macro_rules!
  2. Macros con repeticiones ($()*)
  3. Macros con capturas de tokens
  4. Macros que generan código repetitivo
  5. Macros para logs (info!, debug!, trace!)
  6. Macros de aserción (assert!, assert_eq!, matches!)
  7. Procedural macros #[proc_macro]
  8. Procedural macros #[proc_macro_derive]
  9. Procedural macros #[proc_macro_attribute]
  10. Derives personalizados
  11. Generación de código en build.rs
  12. Incluir archivos externos (include_str!, include_bytes!)
  13. cfg! y macros condicionales
  14. concat!, env!, option_env!
  15. Macros para FFI
  16. Macros para DSLs internos
  17. Macros para test parametrizado
  18. Macros para tracing de rendimiento
  19. quote y syn en procedural macros
  20. Límites de macros (higiene)
5. Gestión de Recursos y RAII
  1. RAII (Resource Acquisition Is Initialization)
  2. Drop trait
  3. Cierre automático de archivos al salir de scope
  4. Liberación de locks al salir de scope
  5. MutexGuard y RwLockReadGuard
  6. ManuallyDrop<T>
  7. MaybeUninit<T>
  8. mem::forget
  9. Smart pointers con semántica RAII
  10. scopeguard (crates externos)
  11. Patrones de cleanup garantizado
  12. Evitar fugas de memoria no deseadas
  13. Control de recursos FFI
  14. Contadores de referencia (Rc, Arc)
  15. Descriptores de archivo y RAII
  16. Sockets y RAII
  17. Mutexes y RAII
  18. Buffers mmap y RAII
  19. Transacciones y RAII
  20. Tareas async abortables con RAII
6. Monitoreo y Observabilidad
  1. tracing crate
  2. Spans y eventos
  3. #[instrument]
  4. Métricas de latencia
  5. Métricas de throughput
  6. Métricas de error rate
  7. Exportadores de métricas (Prometheus, etc.)
  8. Muestreo de eventos de alto volumen
  9. Logging estructurado en JSON
  10. Correlación de requests distribuidos
  11. Propagación de contexto en async
  12. Inicio y fin de span por request
  13. Identificadores de request
  14. Monitoreo de heap
  15. Monitoreo de file descriptors abiertos
  16. Monitoreo de latencia de syscalls
  17. Límites de memoria en contenedores
  18. Límites de CPU en contenedores
  19. Alertas y umbrales
  20. Integración con APM externos
7. Gestión de Memoria y Bajo Nivel
  1. Ausencia de GC en Rust
  2. Propiedad y liberación determinista
  3. Stack vs heap
  4. Box<T> para heap
  5. Vec<T> como buffer dinámico
  6. String como buffer dinámico UTF-8
  7. Box<[T]> y slices en heap
  8. Box<dyn Trait>
  9. Pin<Box<T>>
  10. Pin<&mut T>
  11. Referencias crudas (*const T, *mut T)
  12. unsafe blocks
  13. unsafe fn
  14. extern "C"
  15. Layout de memoria con #[repr(C)]
  16. Acceso sin chequear a slices (get_unchecked)
  17. Eliminación manual de bounds checks
  18. Aliasing y &mut T
  19. Volátiles (ptr::read_volatile, ptr::write_volatile)
  20. MaybeUninit<T> para inicialización diferida
  21. Zero-cost abstractions
  22. Inlining y #[inline(always)]
  23. Eliminación de branching con match
  24. Control fino de panic = abort
  25. #![no_std]
  26. Usar core en entornos embebidos
  27. Arranque bare-metal (#[no_main])
  28. Interrupciones en microcontroladores (#[interrupt])
  29. Memoria compartida en ISR
  30. unsafe encapsulado en HALs embebidos
Implementación y Distribución
1. Herramientas Generales del Entorno
  1. rustup para toolchains
  2. cargo como orquestador
  3. rustc como compilador
  4. rustfmt para formato
  5. clippy para lints
  6. cargo audit para seguridad
  7. cargo deny para licencias
  8. cargo outdated para actualizar versiones
  9. cargo udeps para limpiar dependencias
  10. cargo tree para inspección de dependencias
  11. cargo metadata para tooling externo
  12. cargo watch para recarga en caliente
  13. just / make para automatización
  14. Scripts build.rs
  15. rust-toolchain.toml para fijar versión
  16. Cachés de compilación incremental
  17. Perfiles dev/release
  18. lto (link-time optimization)
  19. panic = abort para binarios pequeños
  20. strip de símbolos en binarios finales
  21. RUSTFLAGS personalizados
  22. Cross-compiling con --target
  23. cross (herramienta de cross-compiling)
  24. Integración con Docker
  25. Integración con Bazel / Buck (cuando aplica)
  26. Integración con Nix
  27. Integración con CI (GitHub Actions, etc.)
  28. Reproducibilidad binaria
  29. Firmas criptográficas de binarios
  30. Publicación interna de artefactos
2. Compilación y Backends
  1. rustc
  2. MIR (Mid-level IR)
  3. LLVM IR
  4. Generación de código máquina
  5. Optimizaciones de LLVM
  6. -C opt-level
  7. -C target-cpu
  8. -C target-feature
  9. -C lto
  10. -C panic=abort
  11. -C relocation-model
  12. -C code-model
  13. -C inline-threshold
  14. -C link-args
  15. Compilación incremental
  16. Cache de incrustaciones (incr comp cache)
  17. Reutilización de artefactos en CI
  18. Compilación cruzada ARM / RISC-V
  19. WASM como objetivo (wasm32-unknown-unknown)
  20. wasm32-wasi
  21. Generación de librerías dinámicas (cdylib)
  22. Generación de librerías estáticas (staticlib)
  23. Binarios independientes (musl)
  24. Minimización de tamaño (opt-level = "z")
  25. Embedded no_std sin sistema operativo
  26. build-std para targets custom
  27. Xargo / cargo para compilación de core personalizada
  28. bindgen para generar bindings C
  29. cbindgen para exponer APIs C
  30. Versionado del compilador requerido (MSRV)
3. Publicación y Versionado de Crates
  1. Cargo.toml con [package]
  2. name, version, edition
  3. authors / license
  4. readme
  5. repository
  6. documentation
  7. homepage
  8. keywords
  9. categories
  10. include / exclude
  11. features
  12. default-features
  13. optional = true
  14. cargo publish
  15. cargo yank
  16. SemVer para crates (MAJOR.MINOR.PATCH)
  17. breaking changes y bump mayor
  18. Compatibilidad semántica en librerías públicas
  19. Compatibilidad binaria de cdylib
  20. Versiones mínimas soportadas (MSRV en README)
  21. Changelogs y CHANGELOG.md
  22. cargo-release para automatizar versiones
  23. Firmar tags y releases
  24. Auditoría de licencias con cargo deny
  25. Auditoría de CVEs con cargo audit
  26. Políticas internas de seguridad
  27. Soporte de plataforma declarado (targets)
  28. Estados experimentales (unstable, nightly-only)
  29. Exponer #[cfg(feature = "foo")] en docs
  30. Estabilidad de APIs unsafe
4. Aplicaciones CLI
  1. Crates clap, argh, structopt
  2. Parsing de argumentos
  3. Subcomandos
  4. Flags y opciones
  5. Validación de input
  6. --help y --version
  7. Autogeneración de ayuda
  8. Autocompletado de shell
  9. Colores y estilos (ansi_term, colored)
  10. Barras de progreso (indicatif)
  11. println! y salida estándar
  12. eprintln! y error estándar
  13. Códigos de salida (std::process::exit)
  14. Logging configurable por flag (-v, -q)
  15. Uso de anyhow o eyre en CLI
  16. Serialización de salida (serde_json)
  17. Interactivo en terminal (prompt)
  18. TUI (crossterm, ratatui)
  19. Tests de CLI vía assert_cmd
  20. Empaquetado estático
  21. Distribución en contenedores
  22. Binarios multiplataforma
  23. Firmas de binario y checksum
  24. Versionamiento semántico del binario
  25. Compatibilidad hacia atrás en flags CLI
  26. Integración con systemd / servicios
  27. Configuración vía archivos (toml, yaml)
  28. Variables de entorno (std::env)
  29. Actualización automática (self-update)
  30. Publicación en gestores de paquetes
5. Aplicaciones Gráficas y de Escritorio
  1. egui
  2. iced
  3. gtk-rs
  4. winit
  5. Motores de juego (bevy)
  6. Renderizado con wgpu
  7. UIs nativas vs webview
  8. Empaquetado multiplataforma
  9. Integración con aceleración GPU
  10. Eventos y loop principal
  11. Recursos compartidos entre hilos UI
  12. Canales de comunicación UI ↔ lógica
  13. Serialización de estado UI
  14. Persistencia de preferencias
  15. Integración con sistemas de archivos
  16. Control de DPI y escalamiento
  17. Integración con backends audio
  18. Janelas múltiples
  19. Controladores de input (teclado, mouse, gamepad)
  20. Soporte de internacionalización en UI
  21. Empaquetado tipo instalador
  22. Firmado de binarios en macOS/Windows
  23. Sandboxing y permisos
  24. Notificaciones del sistema
  25. Integración con portapapeles
  26. Arrastrar y soltar
  27. Actualización auto-generada (autoupdater)
  28. Integración con WebAssembly para componentes
  29. Reutilización de lógica Rust en frontend web
  30. Herramientas de depuración visual
6. Internacionalización (i18n) y Localización (l10n)
  1. Soporte de Unicode en String
  2. Formato localizado de números y fechas (crates externos)
  3. Carga de catálogos de traducción
  4. Selección dinámica de idioma
  5. Separación de recursos por locale
  6. Plantillas de mensajes parametrizados
  7. Integración de i18n en CLI
  8. Integración de i18n en GUI
  9. Internacionalización en aplicaciones web (axum, actix)
  10. Mensajes de error traducibles
  11. Recursos de texto estáticos empaquetados (include_str!)
  12. Detección de locale del sistema
  13. Pluralización y reglas gramaticales
  14. Formato de monedas y unidades
  15. Localización offline en binarios estáticos
  16. Actualización de catálogos sin recompilar
  17. no_std y mensajería mínima
  18. i18n en firmware embebido (pantallas pequeñas)
  19. Soporte RTL (right-to-left)
  20. Compatibilidad con estándares gettext
  21. Convenciones culturales en fechas/hora
  22. Adaptación de layouts UI a idiomas
  23. Internacionalización de documentación pública
  24. Mantenimiento de catálogos en repositorios
  25. Tests que validan traducciones
  26. Versionado de recursos lingüísticos
  27. Seguridad frente a inyección en plantillas traducibles
  28. Selección de idioma vía variables de entorno
  29. Fallbacks de idioma
  30. Integración con pipelines de CI para i18n
Internals
1. Compilador de Rust (rustc)
  1. Fases del compilador
  2. Parseo del código fuente
  3. Árvore de sintaxis (AST)
  4. AST desugaring
  5. HIR (High-level IR)
  6. MIR (Mid-level IR)
  7. Borrow checker
  8. Inferencia de lifetimes
  9. Resolución de tipos
  10. Monomorfización de genéricos
  11. Optimización en MIR
  12. Traducción a LLVM IR
  13. Optimizaciones de LLVM
  14. Generación de código máquina final
  15. Enlazado (linking)
  16. rustc --emit
  17. rustc --emit=mir (nightly)
  18. rustc --emit=llvm-ir
  19. rustc --emit=asm
  20. Control de lint con #![deny], #![warn]
  21. #[inline] y sugerencias de optimización
  22. #[cold] para rutas raras
  23. #[must_use] para resultados críticos
  24. #[repr(C)] para FFI estable
  25. #[no_mangle] para símbolos exportados
  26. #[link(name = "...")]
  27. Driver de compilación en cargo
  28. Caches de compilación incremental
  29. Hashes de contenido para recompilación selectiva
  30. Flags de depuración y symbols (-g)
2. Modelo de Ejecución
  1. Binarios nativos
  2. Librerías dinámicas (cdylib)
  3. Librerías estáticas (staticlib)
  4. Binarios estáticos (musl)
  5. WASM (wasm32-unknown-unknown)
  6. WASI (wasm32-wasi)
  7. no_std en entornos bare-metal
  8. #[no_main] para runtime propio
  9. Punto de entrada fn main()
  10. panic! como abort o unwind
  11. panic = abort en Cargo.toml
  12. panic = unwind
  13. Stack unwinding y catch_unwind
  14. Manejadores panic::set_hook
  15. Inicialización estática
  16. Orden de static init
  17. Finalización a través de Drop
  18. RAII para cleanup determinista
  19. Drop en cascada
  20. Threads del sistema operativo (std::thread)
  21. Futures y ejecutores async en espacio de usuario
  22. Pools de hilos vs loops event-driven
  23. Bloqueo vs no-bloqueo en I/O
  24. Programación lock-free
  25. Exclusión mutua con Mutex
  26. RwLock para acceso paralelo de solo lectura
  27. Atomics y órdenes de memoria
  28. Volátil para MMIO
  29. Interacciones con señales del SO
  30. Integración con FFI de C en runtime
3. Modelo de Datos
  1. Representación en memoria de structs
  2. #[repr(Rust)] por defecto
  3. #[repr(C)] para compatibilidad ABI con C
  4. #[repr(packed)]
  5. #[repr(transparent)]
  6. Orden y alineación de campos
  7. Enum layout optimizado (Option<&T> sin overhead)
  8. Nichos de valores no usados (niche optimization)
  9. Box<T> como puntero único a heap
  10. Rc<T> con conteo de referencias single-thread
  11. Arc<T> con conteo de referencias thread-safe
  12. Cell<T> y RefCell<T> para mutabilidad interior
  13. UnsafeCell<T> como primitiva base de interior mutability
  14. Zonas exclusivas de referencia mutable (&mut T)
  15. Reglas de aliasing en borrow checker
  16. Send para traspaso seguro entre hilos
  17. Sync para acceso compartido seguro
  18. Unpin y movimiento seguro de futures
  19. Pin<&mut T>
  20. MaybeUninit<T> para inicialización manual
  21. ManuallyDrop<T> para controlar Drop
  22. Propiedad lineal como contrato estático
  23. Ciclos de referencia con Rc
  24. Weak<T> para romper ciclos
  25. Fugas de memoria intencionales (leak)
  26. Layout de closures y capturas
  27. dyn Trait y fat pointers (puntero + vtable)
  28. Llamadas virtuales vía vtable
  29. #[inline] y monomorfización en genéricos
  30. Eliminación de código muerto en monomorfización
4. Modelo C y FFI
  1. extern "C" en funciones
  2. #[no_mangle] para nombres estables
  3. #[repr(C)] en structs para FFI
  4. Punteros crudos (*const T, *mut T)
  5. unsafe en llamadas FFI
  6. Traducción de enum a C
  7. Strings CString
  8. CStr
  9. Buffers *mut u8
  10. Longitud y ownership cruzando la frontera FFI
  11. Callbacks desde C hacia Rust
  12. Callbacks de Rust hacia C
  13. ABI estable entre Rust y C
  14. ABI entre Rust y C++
  15. bindgen para generar bindings desde headers C
  16. cbindgen para exponer headers C desde Rust
  17. Reglas de seguridad al exponer punteros
  18. Gestión de memoria compartida con librerías C
  19. #[link(name = "...")]
  20. #[link(kind = "static")]
  21. #[link(kind = "dylib")]
  22. Cargar librerías dinámicas en runtime
  23. Paso de structs complejos a C
  24. Paso de callbacks con extern "C" fn
  25. Manejo de errores en FFI (errno, códigos de error)
  26. Invariantes documentadas en funciones unsafe
  27. Pruebas de integración con librerías C existentes
  28. Construcción cruzada para plataformas embebidas
  29. Integración con kernels / drivers
  30. no_std y FFI en firmware
5. Extensiones y Casos Especiales
  1. no_std y entornos sin sistema operativo
  2. Sistemas embebidos ARM Cortex-M
  3. RISC-V embebido
  4. Mapeo de registros de hardware con volatile
  5. Interrupciones (#[interrupt])
  6. Bootloaders en Rust
  7. Sistemas operativos escritos en Rust
  8. Kernels monolíticos vs microkernels en Rust
  9. Drivers de dispositivo en Rust
  10. Controladores de red en Rust
  11. Librerías criptográficas sin std
  12. Criptografía con no_std
  13. Randomness seguro (rand_core)
  14. #![forbid(unsafe_code)] en capas superiores
  15. unsafe encapsulado en HALs
  16. WebAssembly (wasm32-unknown-unknown)
  17. WASI (wasm32-wasi)
  18. Llamadas host ↔ WASM
  19. Limitaciones de asignador en WASM
  20. Serialización compacta para WASM
  21. Portado de lógica Rust a frontend web
  22. Reutilización de core logic en CLI y servidor
  23. Reutilización de lógica en microcontroladores
  24. Estrategias para panic en entornos sin stdout
  25. panic-halt y panic-abort
  26. Arranque seguro y watchdog
  27. Integridad de memoria en dispositivos críticos
  28. Certificación de software seguro
  29. Política de revisiones de unsafe
  30. Evolución futura del lenguaje, del borrow checker y de async nativo

4 - Shell

Introducción
1. Historia de los shells en Unix
  1. Bourne Shell (sh), csh y ksh
  2. Bash: origen, GNU y licenciamiento
  3. POSIX Shell: estandarización y portabilidad
  4. Evolución de Bash 1.x → 2.x → 3.x → 4.x → 5.x
  5. Línea temporal de características (arrays, asociativos, coproc, globstar)
  6. Comunidad, mantenimiento y políticas de releases
2. Shells y compatibilidad
  1. sh vs bash vs dash vs ksh vs zsh
  2. Conformidad POSIX y “bashismos”
  3. Detección de shell activo y versión ($SHELL, bash --version)
  4. Portabilidad entre distribuciones y BSD/macOS
  5. BusyBox/Almquist (ash) y entornos mínimos
  6. Limitaciones en sistemas embebidos
3. Instalación y actualización de Bash
  1. Distribuciones Linux (apt, dnf, pacman, zypper)
  2. macOS (Homebrew, MacPorts)
  3. Windows (WSL, MSYS2, Git Bash, Cygwin)
  4. Compilación desde fuente y opciones comunes
  5. Selección de shell por defecto (chsh, /etc/shells)
  6. Verificación de instalación y PATH
4. Ejecutar el shell y scripts
  1. Sesión interactiva vs no interactiva
  2. Shebangs (#!/bin/sh, #!/usr/bin/env bash)
  3. Ejecución directa, bash script.sh, permisos y chmod +x
  4. source/. vs ejecución en subshell
  5. Flags y modos (-c, -i, -l, -O, -o, -v, -x)
  6. Entrada/salida estándar, tuberías y redirecciones básicas
5. Terminales y línea de comandos
  1. TTY vs PTY
  2. Emuladores de terminal (GNOME Terminal, iTerm2, Windows Terminal, kitty, Alacritty)
  3. Multiplexores (tmux, screen)
  4. Readline, historial y edición de línea
  5. Autocompletado y bash-completion
  6. Copiado/pegado, mouse reporting y scrollback
6. Editores y herramientas de desarrollo
  1. Vim, Neovim, Emacs, Nano, VS Code
  2. LSP/“language server” para shell (bash-language-server)
  3. Formateadores y linters (shfmt, ShellCheck)
  4. Integración con depuradores y perfiles de ejecución
  5. Fragmentos, plantillas y snippets de scripts
  6. Proyectos de ejemplos y repos de referencia
Fundamentos
1. Conceptos básicos del shell
  1. Comandos, argumentos y opciones
  2. Estado de salida y semántica de éxito/fracaso
  3. Rutas absolutas vs relativas
  4. PATH, búsqueda de comandos y hashing de rutas
  5. Builtins vs ejecutables externos
  6. Separadores, espacios y saltos de línea
2. Variables y entorno
  1. Definición, asignación y alcance
  2. Exportación al entorno (export)
  3. Variables de entorno comunes (PATH, HOME, USER, SHELL)
  4. Variables locales vs globales
  5. env, printenv y archivos de entorno
  6. Convenciones de nombres y mayúsculas
3. Tipos de datos prácticos
  1. Cadenas y evaluación de palabras
  2. Números en aritmética de shell
  3. Arrays indexados (bash)
  4. Arrays asociativos (bash)
  5. Valores nulos y no definidos
  6. Lectura segura de datos con IFS
4. Citas y expansión
  1. Comillas simples vs dobles
  2. Escape con barra invertida
  3. Expansión de variables
  4. Sustitución de comandos
  5. Expansión aritmética
  6. Orden de expansiones y efectos colaterales
5. Globbing y patrones
  1. Patrón *, ?, []
  2. extglob y patrones extendidos
  3. globstar y coincidencia recursiva
  4. nullglob, failglob, nocaseglob
  5. Diferencias con expresiones regulares
  6. Interacciones con IFS y splitting
6. Operadores
  1. Aritméticos en (( ))
  2. Comparación en [ ] y [[ ]]
  3. Operadores de archivo (-e, -f, -d, -r, -w, -x)
  4. Operadores de cadena (=, !=, <, >, =~)
  5. Asignación compuesta y let
  6. Precedencia práctica en shell
7. Control de flujo
  1. if, elif, else
  2. case con patrones
  3. for clásico y for … in
  4. while y until
  5. break, continue, exit, return
  6. Sentencias condicionales cortas con && y ||
8. Funciones
  1. Definición y llamada
  2. Parámetros posicionales y $#, $*, $@, $?, $$, $!
  3. local y sombras de variables
  4. Valores de retorno y echo/stdout
  5. Bibliotecas de funciones y source
  6. Namespacing por convención
9. Estado de salida y manejo de errores
  1. Códigos de retorno y set -e
  2. pipefail y errores en tuberías
  3. set -u y variables no definidas
  4. trap y captura de señales
  5. Limpieza y funciones cleanup
  6. Diseño de scripts “fail-fast”
10. Opciones del shell
11. set para opciones POSIX
12. shopt para opciones específicas de bash
13. Modo POSIX vs modo bash
14. Opciones de globbing y expansión
15. Ajustes de historia y readline
16. Persistencia en dotfiles
Estructuras y manipulación de datos
1. Cadenas en shell
  1. Longitud, subcadenas y sustituciones
  2. Borrado de prefijos/sufijos con patrones
  3. Sustitución global de patrones
  4. Conversión de mayúsculas/minúsculas
  5. Manejo de caracteres especiales y binarios
  6. Normalización de fin de línea y codificaciones
2. Arrays indexados
  1. Declaración, inicialización y expansión
  2. Acceso por índice y rebanado
  3. Iteración sobre índices y valores
  4. Operaciones de inserción y borrado
  5. Longitud y expansión segura con [@]
  6. Errores comunes con IFS y splitting
3. Arrays asociativos
  1. Declaración y asignación de claves
  2. Iteración por clave y valor
  3. Existencia de claves y pruebas
  4. Copias y referencias
  5. Serialización simple de mapas
  6. Limitaciones de portabilidad
4. Lectura y parsing
  1. read seguro con -r y IFS
  2. mapfile/readarray
  3. Lectura de campos, CSV y delimitadores
  4. getopts para opciones cortas
  5. getopt/GNU para opciones largas
  6. Validación de entrada y mensajes de ayuda
5. Expresiones regulares y patrones
  1. [[ string =~ regex ]] en bash
  2. grep básico, ERE y PCRE según herramienta
  3. sed para sustituciones en flujo
  4. awk para campos y registros
  5. Limitaciones de regex en [[ ]]
  6. Casos de uso mezcla regex/patrones
6. Archivos y directorios
  1. Comprobaciones de archivo y directorio
  2. Metadatos y permisos
  3. Timestamps y touch
  4. Listados y filtros
  5. Búsqueda con find
  6. Trabajo seguro con nombres con espacios y saltos de línea
7. Redirecciones y descriptores
  1. >, >>, <, 2>, &>, <>
  2. exec para reasignar FDs
  3. tee y duplicación de salida
  4. noclobber y set -C
  5. Here-docs (<<, <<-) y here-strings (<<<)
  6. Pseudodispositivos y /dev/null
8. Tuberías y procesos
  1. Piping entre múltiples comandos
  2. Efectos de subshell en (...)
  3. Agrupación { ...; }
  4. xargs y -0 con -print0
  5. parallel para concurrencia
  6. Consideraciones de rendimiento
9. Sustituciones y procesos especiales
  1. Sustitución de comandos $( )
  2. Sustitución de procesos <( ) y >( )
  3. Co-procesos coproc
  4. Nombres de tuberías mkfifo
  5. /dev/tcp y /dev/udp en bash
  6. Captura de stderr por separado
Programación estructurada y modular
1. Organización de scripts
  1. Estructura de carpetas y convenciones
  2. Cabeceras, licencia y metadatos
  3. Funciones reutilizables y bibliotecas
  4. “Main” y flujo de ejecución
  5. Gestión de errores y logging
  6. Salidas y códigos de retorno
2. Interfaz de línea de comandos
  1. Diseño de --help y --version
  2. Subcomandos por convención
  3. Validación de parámetros y contratos
  4. Mensajes de uso y ejemplos
  5. Colores y TTY detección
  6. Compatibilidad con sudo
3. Configuración y entorno
  1. Archivos .env y dotenv CLI
  2. Variables de entorno y precedencia
  3. Archivos INI/TOML/YAML con grep/sed/awk/jq/yq
  4. Plantillas con here-doc y placeholders
  5. Rutas relativas y absolutas robustas
  6. Detección de sistema y distros
4. Sourcing y módulos
  1. source de librerías internas
  2. Control de colisiones de nombres
  3. Variables readonly y constantes
  4. Carga condicional y “guardas”
  5. Versión mínima de bash y chequeos
  6. Dependencias de herramientas externas
5. Estilo y calidad
  1. Guías de estilo (Google Shell Style Guide)
  2. ShellCheck: categorías y reglas comunes
  3. shfmt: indentación y formato
  4. Nombres de funciones y variables
  5. Comentarios y secciones
  6. Revisiones y code review
6. Documentación
  1. Cabeceras con descripción y uso
  2. --help autogenerado por funciones
  3. Manuales man mínimos con ronn/pandoc
  4. README de CLI
  5. Ejemplos reproducibles
  6. Notas de compatibilidad
7. Pruebas
  1. bats-core: estructura y aserciones
  2. shUnit2: suites y fixtures
  3. cram/tap: pruebas de línea de comandos
  4. Mocks de comandos con PATH y wrappers
  5. Tests de integración con contenedores
  6. Cobertura y medición de rutas de error
8. Depuración
  1. set -x y PS4
  2. bash -x y trazas
  3. set -v y eco de entradas
  4. trap ERR y diagnósticos
  5. printf/echo dirigidos a stderr
  6. Reproducibilidad de fallos
9. Rendimiento y benchmarking
  1. time y /usr/bin/time
  2. hyperfine para CLIs
  3. Minimización de subshells
  4. Sustituciones eficientes vs pipelines
  5. Uso de awk/sed/perl cuando corresponda
  6. Perfilado con strace/dtruss (lectura de alto nivel)
Texto, datos y utilidades de Unix
1. Búsqueda y filtrado
  1. grep, egrep, ripgrep
  2. head, tail, sed filtros básicos
  3. awk para columnas y agregaciones
  4. cut, paste, tr
  5. sort, uniq, comm, join
  6. nl, wc, fold, fmt
2. Estructuras y formatos
  1. CSV robusto con delimitadores
  2. TSV y cut --output-delimiter
  3. JSON con jq
  4. YAML con yq
  5. INI con awk/grep patrones
  6. Binarios y xxd/hexdump
3. Archivos y compresión
  1. tar y variantes de compresión
  2. gzip, bzip2, xz, zstd
  3. zip/unzip
  4. Extracción selectiva y streaming
  5. Integridad y checksums (md5sum, sha256sum)
  6. Archivos temporales con mktemp
4. Sistema de archivos
  1. stat, ls y formatos
  2. chmod, chown, umask
  3. df, du y cuotas
  4. Enlaces duros y simbólicos
  5. Montajes y puntos de montaje
  6. lsof y archivos abiertos
5. Búsqueda y ejecución
  1. find con pruebas de tiempo y tamaño
  2. -exec y -print0
  3. xargs paralelo y seguro
  4. Limitación de profundidad
  5. Selección por permiso/usuario/grupo
  6. Eliminación segura y confirmación
6. Flujo y transformación
  1. tee para bifurcar
  2. Filtros composables
  3. Tratamiento de errores en pipelines
  4. awk como “mini lenguaje”
  5. sed multi-línea y hold space
  6. Mantenimiento de orden estable
Concurrencia, procesos y sistema
1. Procesos y jobs
  1. Ejecución en background &
  2. jobs, fg, bg
  3. wait y recolección
  4. disown y longevidad
  5. nohup y sesiones
  6. Subshells vs shell actual
2. Señales y trap
  1. SIGINT, SIGTERM, SIGHUP
  2. Limpieza de recursos
  3. Trampas para EXIT y ERR
  4. Reintentos exponenciales
  5. Ventanas de carrera y bloqueos
  6. flock y exclusión mutua
3. Paralelismo práctico
  1. xargs -P y límites
  2. GNU parallel
  3. Coprocesos coproc
  4. Paralelismo por archivos y sharding
  5. Estrategias de backoff
  6. Observabilidad básica
4. Tiempo y temporización
  1. date y formatos portables
  2. sleep, usleep (según SO)
  3. timeout y cancelación
  4. Medición con time y SECONDS
  5. Zonas horarias y TZ
  6. Rounding y diferencias de tiempo
5. Programación y scheduling
  1. cron y crontab
  2. anacron
  3. systemd timers
  4. at/batch
  5. systemd-run para tareas únicas
  6. Logs y rotación con logrotate
6. Recursos del sistema
  1. ulimit y límites de FDs
  2. nice y renice
  3. Afinidad y taskset (Linux)
  4. Memoria y free/vm_stat
  5. CPU y mpstat/top/htop
  6. I/O y iostat/dstat
Redes y comunicación
1. Transferencias
  1. curl y wget
  2. scp, sftp, rsync
  3. Autenticación con claves
  4. Verificación de certificados
  5. Reanudación y --continue-at
  6. Throttling de ancho de banda
2. Conectividad
  1. ping, ping6
  2. traceroute/mtr
  3. dig/host
  4. nc/netcat y puertos
  5. /dev/tcp para testing
  6. Proxies y variables de entorno
3. SSH y automatización
  1. ssh y opciones de control
  2. ~/.ssh/config y multiplexación
  3. Agentes ssh-agent/gpg-agent
  4. Ejecución remota paralela
  5. Transferencias atómicas con rsync
  6. Túneles y port forwarding
4. APIs y formatos
  1. curl con JSON
  2. jq para parseo y filtros
  3. Autenticación por tokens
  4. Retries y backoff
  5. Logging de peticiones y respuestas
  6. Sanitización de secretos en logs
Entorno, dotfiles y personalización
1. Inicio de sesión y perfiles
  1. Shell de login vs no login
  2. .bashrc, .bash_profile, .profile
  3. Orden de carga y herencia
  4. Distinciones macOS/Linux
  5. Scripts globales en /etc
  6. Depuración de inicio con set -x
2. Prompt y estética
  1. PS1, PS2, PS4
  2. Colores ANSI y escapes
  3. Información de git y estado
  4. Prompts por contexto (root, prod)
  5. Separadores unicode y símbolos
  6. Detección de TTY para colores
3. Historial y productividad
  1. HISTFILE, HISTSIZE, HISTCONTROL
  2. history y expansión !
  3. Búsqueda incremental con Readline
  4. Atajos de edición (emacs/vi mode)
  5. fc y edición del último comando
  6. Deduplicación de comandos
4. Autocompletado
  1. bash-completion paquetes
  2. Completados personalizados
  3. Context-aware completion
  4. Cache y rendimiento
  5. Compatibilidad entre distros
  6. Mantenimiento de scripts de completion
5. Gestión del entorno
  1. Variables por proyecto
  2. direnv y hooks
  3. Versionado de herramientas (asdf, mise)
  4. Nix y shells reproducibles
  5. Plantillas de perfiles
  6. Seguridad de archivos de inicio
Seguridad en shell
1. Principios básicos
  1. Citar siempre las variables
  2. Evitar word splitting accidental
  3. Manejo de IFS seguro
  4. set -Eeuo pipefail en scripts críticos
  5. umask y permisos por defecto
  6. noclobber y sobrescrituras
2. Inyección y sanitización
  1. Construcción segura de comandos
  2. Evitar eval
  3. Validación de rutas y nombres
  4. Filtrado de entrada y listas blancas
  5. Limitación de globbing inesperado
  6. Escapes al invocar herramientas
3. Archivos temporales
  1. mktemp y directorios dedicados
  2. Limpieza con trap
  3. Colisiones y condiciones de carrera
  4. Nombres predecibles a evitar
  5. tmpfs y consideraciones de rendimiento
  6. Permisos y herencia en TMPDIR
4. Secretos y credenciales
  1. Variables de entorno sensibles
  2. Archivos .netrc y permisos
  3. Pass/Keychain/GPG
  4. Redacción de logs
  5. Integración con gestores de secretos
  6. Expiración y rotación
5. Casos conocidos
  1. Shellshock y funciones en entorno
  2. PATH envenenado
  3. Scripts sudo inseguros
  4. ssh sin restricción de comandos
  5. tar y paths relativos
  6. find -exec y comodines
Portabilidad y diferencias de plataformas
1. GNU vs BSD
  1. sed -i y compatibilidad
  2. date y formatos
  3. xargs flags por defecto
  4. tar opciones divergentes
  5. readlink y realpath
  6. stat campos y sintaxis
2. Linux vs macOS vs *BSD
  1. Utilidades de red
  2. Directorios del sistema
  3. Enlaces simbólicos y Finder
  4. Lanzadores y launchd
  5. Homebrew y rutas en ARM
  6. Frameworks y restricciones SIP
3. Entornos mínimos
  1. BusyBox/ash
  2. Alpine y musl
  3. Imágenes scratch/distroless
  4. Docker entrypoints en sh
  5. Shells en initramfs
  6. Limitaciones de locales
4. Windows y POSIX
  1. WSL y interoperabilidad
  2. MSYS2/Cygwin
  3. CRLF vs LF
  4. Rutas y letras de unidad
  5. Procesos y señales
  6. Permissions y ACLs
Integración con ecosistema y empaquetado
1. Gestores de paquetes del sistema
  1. apt, dnf/yum, pacman, zypper
  2. brew, port
  3. nix/guix
  4. snap/flatpak para CLIs
  5. Repos privados y mirrors
  6. Cachés y proxies
2. Distribución de scripts
  1. Instalación en /usr/local/bin
  2. Paquetización DEB/RPM básica
  3. Publicación via tarballs
  4. Checksums y firmas
  5. Versionado semántico por convención
  6. Changelogs y notas de versión
3. Contenedores
  1. Dockerfiles con sh/bash
  2. Entrypoint vs CMD
  3. Señales y PID 1
  4. Imágenes multi-stage
  5. Salud y readiness checks
  6. Logs y STDOUT/STDERR
4. CI/CD
  1. Ejecutores y runners
  2. Caching de dependencias
  3. Matrices y paralelismo
  4. Artefactos y reportes
  5. Lint/test en pipelines
  6. Firmas y supply chain
5. Interoperabilidad
  1. Makefiles y targets
  2. Invocación desde otros lenguajes
  3. Subprocesos y códigos de retorno
  4. IPC simple con FIFOs
  5. JSON/YAML como interfaz
  6. CLI contract-first
Redes, servicios y sistemas
1. Gestión de servicios
  1. systemd y systemctl
  2. SysV init scripts
  3. Launchd en macOS
  4. Supervisores (supervisord, s6)
  5. Logs de sistema y journalctl
  6. Rotación y retención
2. Almacenamiento y backups
  1. rsync avanzado
  2. Snapshots y LVM/ZFS (conceptos)
  3. Verificación de integridad
  4. Backups diferenciales/incrementales
  5. Restores y pruebas periódicas
  6. Cifrado en repositorios
3. Observabilidad
  1. top, htop, atop
  2. vmstat, iostat, dstat
  3. lsof y fugas de descriptores
  4. ss/netstat
  5. Logging estructurado con jq
  6. Exportadores y métricas simples
4. Seguridad operativa
  1. sudo políticas y NOPASSWD
  2. pam y restricciones
  3. faillock/fail2ban básicos
  4. Chequeos de permisos en scripts
  5. Listas de control y setcap
  6. Auditoría de comandos críticos
Casos de uso y patrones
1. Procesamiento masivo de archivos
  1. Canonización de nombres
  2. Renombrado seguro
  3. Extracción y partición
  4. Validaciones de estructura
  5. Resúmenes y reportes
  6. Reintentos de operaciones fallidas
2. Pipelines de datos
  1. Extracción → Transformación → Carga
  2. Logs y métricas por etapa
  3. Paralelismo por particiones
  4. Reprocesamiento idempotente
  5. Control de versiones de pipeline
  6. Almacenamiento temporal y limpieza
3. CLI de utilería
  1. Plantillas --help
  2. Comandos anidados
  3. Config por archivo y env
  4. Verbosidad y --quiet
  5. Códigos de retorno estandarizados
  6. Tests de humo automáticos
4. Automatización de despliegues
  1. Construcción y empaquetado
  2. Publicación artefactos
  3. Migraciones y rollbacks
  4. Checks de salud post-deploy
  5. Canary y gradual rollouts
  6. Auditoría y trazabilidad
5. Mantenimiento y tareas programadas
  1. Limpieza de caches
  2. Rotación de logs
  3. Verificación de espacio
  4. Renovación de certificados
  5. Respaldo y rotación
  6. Alertas y notificaciones
Lectura, escritura y formatos específicos
1. CSV/TSV robusto
  1. Delimitadores y comillas
  2. Filtrado por columnas
  3. Uniones y mezclas
  4. Limpieza de encabezados
  5. Detección de codificaciones
  6. Conversión a JSON/YAML
2. JSON
  1. Extracción y transformación con jq
  2. Validación y esquema básico
  3. Merge y patch
  4. Orden y pretty-print
  5. Streams y SLURP
  6. Filtrado por claves
3. YAML
  1. yq para consultas
  2. Conversión YAML↔JSON
  3. Anclas y alias (operativo)
  4. Plantillas con here-doc
  5. Splits por documentos
  6. Validación básica
4. Texto y codificaciones
  1. UTF-8 por defecto
  2. Eliminación de BOM
  3. Normalización de saltos de línea
  4. Reemplazos seguros de binarios
  5. Detección con file
  6. Reglas de localización
Internos del shell
1. Ciclo de vida de un comando
  1. Tokenización y parsing
  2. Expansiones en orden
  3. Globbing y splitting
  4. Redirecciones y FDs
  5. Fork/exec y espera
  6. Recolección del estado
2. Builtins esenciales
  1. cd, echo, printf
  2. test/[, [[
  3. read, mapfile
  4. set, shopt
  5. exec, eval (con cautela)
  6. trap, ulimit
3. Readline y edición
  1. .inputrc y bindings
  2. Modos emacs/vi
  3. Macros simples
  4. Compleciones dinámicas
  5. Historial y expansión !
  6. Control de mayúsculas/minúsculas
4. Opciones y comportamiento
  1. POSIX mode
  2. Emulación de sh
  3. Opciones heredadas
  4. Variables especiales de bash
  5. Límite de recursión de funciones
  6. Máximos de longitud de línea/argv
Internacionalización y locales
1. Locales del sistema
  1. LC_ALL, LANG, LC_* variables
  2. Efectos en sort/grep/awk
  3. Estabilidad con LC_ALL=C
  4. Fechas, números y collations
  5. Conversión de charset
  6. Scripts reproducibles y locales fijas
2. Mensajes y traducción (nivel operativo)
  1. Mensajes de ayuda neutrales
  2. Señales y textos estándar
  3. Salidas parsables vs human-friendly
  4. Documentación bilingüe por convención
  5. Evitar dependencias regionales
  6. Pruebas con locales variados
Buenas prácticas y antipatrones
1. Citar siempre expansiones
2. Evitar for x in $(cmd) para líneas
3. Preferir read -r con IFS controlado
4. Manejo de errores explícito
5. No abusar de subshells innecesarios
6. Reemplazar cat inútil (UUOC)
7. grep -q para pruebas silenciosas
8. set -Eeuo pipefail cuando aplique
9. Validar entradas externas
10. Registrar acciones críticas
Migración y compatibilidad
1. De bash a POSIX sh
2. Detección y eliminación de bashismos
3. Sustituciones de [[ → [ cuando sea posible
4. mapfile/arrays en entornos sin bash
5. extglob y alternativas
6. Pruebas cruzadas en shells comunes
Catálogo de recetas frecuentes
1. Parseo robusto de flags con getopts
2. Leer fichero línea a línea seguro
3. Procesar grandes árboles con find -print0
4. Pipelines con manejo de errores
5. Retries con backoff exponencial
6. Locking con flock
7. Logging con niveles y timestamps
8. Rotación de logs por tamaño
9. Descargas con checksum y verificación
10. Recolección y limpieza a la salida
Referencias y ecosistema
1. Manuales (man bash, POSIX)
2. Guías de estilo reconocidas
3. Proyectos ejemplo y plantillas
4. Herramientas de verificación (ShellCheck, shfmt)
5. Conjuntos de pruebas (bats, shUnit2)
6. Comunidades y recursos de aprendizaje