Proceso, diseno y construccion sistematica (0x60XX)

Reglas de metodo: como disenar y construir codigo de calidad paso a paso.

• Programación 1
• Cátedra
  • Introducción a Programación 1
  • Pacto de cursada
  • Programación 1
  • Finales
• Apunte
  • Índice del Apunte
  • Bloque 1: Fundamentos
    • Fundamentos de Computación y Algoritmos
    • Introducción a la programación en C
    • Control de Flujo Gradual
    • Funciones y descomposición funcional
    • Compilación
    • Testing y Verificación Básica
    • Introducción al Diseño por Contrato
    • Introducción
  • Bloque 2: Memoria
    • Modelo de Memoria y Pila
    • Punteros
    • Secuencias: Arreglos y Cadenas
    • Archivos de Texto
    • Memoria Dinámica
    • Aritmética de punteros y matrices dinámicas
    • Estructuras y Tipos Compuestos
    • Representación de Números y Aritmética
    • Conversión de Tipos (Casts) en C
    • Definición de Tipos y Alias
    • Tipos Enumerativos (enum)
  • Bloque 3: Algoritmos y Estructuras de Datos
    • Matrices
    • Tipos de Datos Abstractos, Pilas y Colas
    • Pilas, Colas y Estructuras Lineales Restringidas
    • Testing Avanzado y Automatización
    • Diseño por Contratos Formal y Verificación
    • Análisis de Complejidad Algorítmica
    • Introducción a la Recursividad
  • Bloque 4: Temas Avanzados
    • Bloque 4: Temas Avanzados
    • Punteros a Funciones
    • Punteros Opacos y Encapsulamiento en C
    • Archivos Binarios
    • Campos de Bits y Operaciones Bitwise
    • Creación de Imágenes de Mapa de Bits
    • Recursión de Cola y Divide y Vencerás
    • Código Idiomático en C
    • Diseño de Interfaces y APIs en C
    • Ingeniería de APIs y Gestión de Compatibilidad
    • Programación Concurrente con Hilos en C
    • Programación de Sockets en C
• Reglas de Estilo y Antipatrones
  • Reglas de Estilo y Antipatrones de Cátedra
  • Registro de Renumeración del Catálogo
  • Sintaxis y formato visual (0x00XX)
    • Sintaxis y formato visual (0x00XX)
    • Reglas (0x00XX)
      • Regla 0x0001h: La claridad y prolijidad son de máxima importancia
      • Regla 0x0002h: Una declaración de variable por línea
      • Regla 0x0003h: Un espacio antes y después de cada operador binario
      • Regla 0x0004h: Cada bloque debe tener una indentación de cuatro espacios respecto a su contenedor y llaves
      • Regla 0x0005h: El asterisco de los punteros debe declararse junto al identificador
      • Regla 0x0006h: Las líneas de código no deben exceder los 79 caracteres
      • Regla 0x0007h: Las llaves deben ubicarse en líneas independientes según el estilo Allman
      • Regla 0x0008h: Alineación vertical consistente en asignaciones y declaraciones consecutivas
      • Regla 0x0009h: Espaciado consistente en declaraciones de doble puntero (tipo **var)
      • Regla 0x000Ah: Prohibición de espacios en blanco antes de separadores de sintaxis (; y ,)
      • Regla 0x000Bh: Prohibición de espacios en blanco alrededor de operadores de acceso a miembros (-> y .)
      • Regla 0x000Ch: Prohibición de espacios en blanco entre operadores unarios (++, --, !) y su operando
      • Regla 0x000Dh: Espacio en blanco obligatorio tras la coma separadora en listas y argumentos
      • Regla 0x000Eh: Prohibición de espacios en blanco internos inmediatamente tras '(' o antes de ')'
      • Regla 0x000Fh: Prohibición de múltiples espacios en blanco consecutivos dentro de una línea de código
      • Regla 0x0010h: Prohibición de llaves redundantes en inicialización de tipos escalares
      • Regla 0x0011h: Validador de espaciado estricto en sentencias de control
      • Regla 0x0012h: Validador de formato canónico en firmas de punteros a función
      • Regla 0x0013h: Detector de etiquetas de salto goto no alineadas al margen izquierdo
      • Regla 0x0014h: Auditor de inicialización de arreglos unidimensionales con exceso de elementos
      • Regla 0x0015h: Validador de espaciado en listas de argumentos y llamadas a funciones
      • Regla 0x0016h: Validador de espaciado en operadores unarios
      • Regla 0x0017h: Agrupá sentencias relacionadas y separá bloques lógicos
  • Nomenclatura e identificadores (0x01XX)
    • Nomenclatura e identificadores (0x01XX)
    • Reglas (0x01XX)
      • Regla 0x0101h: Los identificadores deben ser descriptivos
      • Regla 0x0102h: Los argumentos de función y las variables locales deben usar snake_case en minúsculas
      • Regla 0x0103h: Las constantes (const o #define) deben nombrarse en MAYUSCULAS_SNAKE_CASE
      • Regla 0x0104h: Los nombres de los archivos deben usar snake_case en minúsculas (sin espacios)
      • Regla 0x0105h: Los nombres de funciones deben usar snake_case estricto en minúsculas
      • Regla 0x0106h: Las variables globales deben ser declaradas como static o usar prefijo g_
      • Regla 0x0107h: Las macros #define deben nombrarse en MAYUSCULAS_SNAKE_CASE
      • Regla 0x0108h: Prohibición de identificadores con caracteres no ASCII (acentos, ñ)
      • Regla 0x0109h: Prohibición de identificadores que colisionen con palabras clave o tipos estándar
      • Regla 0x010Ah: Prohibición de identificadores con prefijos reservados para el compilador (__ o _[A-Z])
      • Regla 0x010Bh: Proporcionalidad en longitud de identificadores según su alcance
      • Regla 0x010Ch: Auditor de identificadores reservados con doble guion bajo o guion bajo inicial
      • Regla 0x010Dh: Auditor de consistencia en nombres de constantes simbólicas
      • Regla 0x010Eh: Prescindí de identificadores genéricos con sufijo numérico o afijos (numero1, num_1, n_a, a_n)
      • Regla 0x010Fh: Prohibición de constantes numéricas mágicas en índices de arreglos
      • Regla 0x0110h: Los booleanos se nombran con prefijo interrogativo
      • Regla 0x0111h: Nombrá en positivo y evitá las dobles negaciones
      • Regla 0x0112h: Usá constantes simbólicas para todo literal con significado
  • Comentarios, documentacion y organizacion de archivos (0x02XX)
    • Comentarios, documentacion y organizacion de archivos (0x02XX)
    • Reglas (0x02XX)
      • Regla 0x0201h: Escribí comentarios que expliquen el 'porqué', no el 'qué'
      • Regla 0x0202h: No dejes código comentado (dead code) en los archivos fuente
      • Regla 0x0203h: Prescindí de comentarios obvios, redundantes o vacíos
      • Regla 0x0204h: Control de longitud máxima de archivos de código (máx 500 líneas)
      • Regla 0x0205h: En archivos .c la inclusión de la cabecera propia debe figurar en primer lugar
      • Regla 0x0206h: Validador de presencia de cabecera de documentación obligatoria por archivo
  • Estructuras de control y flujo (0x10XX)
    • Estructuras de control y flujo (0x10XX)
    • Reglas (0x10XX)
      • Regla 0x1001h: Todas las estructuras de control deben utilizar llaves
      • Regla 0x1002h: Restringí el uso de break y continue; preferí lazos con bandera de control
      • Regla 0x1003h: Utilizá el lazo for para iteraciones con rango o contador definido y while para lazos controlados por condiciones lógicas
      • Regla 0x1004h: Las condiciones complejas deben simplificarse o comentarse
      • Regla 0x1005h: Reemplazá las condiciones ambiguas basadas en la 'veracidad' (truthiness) del tipo de dato
      • Regla 0x1006h: No utilizar la instrucción goto
      • Regla 0x1007h: No utilizar el operador condicional (ternario) ?:
      • Regla 0x1008h: Toda instrucción switch debe incluir un caso default
      • Regla 0x1009h: Prohibición de asignaciones simples dentro de condiciones lógicas
      • Regla 0x100Ah: Prohibición de estructuras de control con cuerpo vacío (if (...);)
      • Regla 0x100Bh: No utilices comparaciones en estilo Yoda ('CONST == variable')
      • Regla 0x100Ch: Espaciado obligatorio alrededor de operadores ternarios ('? :')
      • Regla 0x100Dh: Prohibición de condiciones de parada compuestas complejas en lazos for
      • Regla 0x100Eh: Delimitación obligatoria con bloque de llaves en lazos do-while
      • Regla 0x100Fh: Prohibición de cláusula else redundante tras sentencia de retorno anticipado
      • Regla 0x1010h: Prohibición de comparaciones encadenadas no idiomáticas en C (a < b < c)
      • Regla 0x1011h: Prohibición de saltos no estructurados goto fuera del patrón canónico de liberación de recursos
      • Regla 0x1012h: Prohibición de expresiones de asignación dentro de estructuras de control
      • Regla 0x1013h: Detector de expresiones booleanas complejas sin paréntesis aclaratorios
      • Regla 0x1014h: Detector de operadores de incremento o decremento múltiples en una misma expresión
      • Regla 0x1015h: Limitá la profundidad de anidación a tres niveles
      • Regla 0x1016h: Documentá el invariante de cada lazo
      • Regla 0x1017h: Escribí condiciones afirmativas y directas
      • Regla 0x1018h: No uses variables de punto flotante como control de lazo
  • Funciones, contratos y modularizacion (0x20XX)
    • Funciones, contratos y modularizacion (0x20XX)
    • Reglas (0x20XX)
      • Regla 0x2001h: Las funciones deben usar cláusulas de guarda y retornos anticipados para reducir la anidación profunda
      • Regla 0x2002h: Las funciones no deben contener printf o scanf, a menos que ese sea su propósito explícito
      • Regla 0x2003h: Todas las funciones deben incluir documentación completa y estructurada
      • Regla 0x2004h: No se permite el uso de variables globales
      • Regla 0x2005h: Cada función debe tener una única responsabilidad (Principio de Responsabilidad Única)
      • Regla 0x2006h: Mantené el alcance de las variables al mínimo posible
      • Regla 0x2007h: Los valores de retorno numéricos deben definirse como constantes de preprocesador o enums
      • Regla 0x2008h: Los ejercicios deben ser resueltos mediante funciones
      • Regla 0x2009h: Los nombres de funciones y procedimientos deben usar snake_case en minúsculas
      • Regla 0x200Ah: Modularización: una función no debe exceder 4 parámetros de entrada
      • Regla 0x200Bh: Prohibición de retornar la dirección de una variable local de stack
      • Regla 0x200Ch: Cada función debe tener a lo sumo un return
      • Regla 0x200Dh: Comentarios de cierre explicativos en bloques de control extensos (> 25 líneas)
      • Regla 0x200Eh: Uso obligatorio de 'void' explícito en funciones sin parámetros
      • Regla 0x200Fh: Prohibición de paréntesis superfluos en sentencia return
      • Regla 0x2010h: Prohibición de reasignar o modificar parámetros recibidos por valor dentro de la función
      • Regla 0x2011h: Prohibición de asignaciones múltiples a una variable sin lectura intermedia (dead store)
      • Regla 0x2012h: Tipo de retorno obligatorio 'int' en la función main()
      • Regla 0x2013h: Detector de bloques else superfluos tras sentencias terminales
      • Regla 0x2014h: Cada función debe caber en una sola idea y en 25 líneas
      • Regla 0x2015h: No dupliques lógica: extraé una función
      • Regla 0x2016h: Escribí el contrato de la función antes de implementarla
      • Regla 0x2017h: Toda funcion recursiva debe tener un caso base explicito
      • Regla 0x2018h: Los comparadores no deben usar resta sujeta a desbordamiento
  • Memoria, punteros y tipos (0x30XX)
    • Memoria, punteros y tipos (0x30XX)
    • Reglas (0x30XX)
      • Regla 0x3001h: Siempre verificá la asignación exitosa de memoria dinámica
      • Regla 0x3002h: Liberá siempre la memoria dinámica y asigná NULL al puntero para mitigar punteros colgantes
      • Regla 0x3003h: No mezcles operaciones de asignación y comparación en una sola línea
      • Regla 0x3004h: Utilizá typedef para definir tipos de estructuras con el sufijo _t
      • Regla 0x3005h: Minimizá el uso de múltiples niveles de indirección (punteros a punteros)
      • Regla 0x3006h: Documentá la propiedad de los recursos al utilizar punteros
      • Regla 0x3007h: Los argumentos de tipo puntero deben ser const siempre que la función no los modifique
      • Regla 0x3008h: Los punteros nulos deben ser inicializados y comparados con NULL, no con 0
      • Regla 0x3009h: Documentá explícitamente los casos en que una función puede retornar NULL
      • Regla 0x300Ah: Utilizá cast explícito al convertir tipos de punteros
      • Regla 0x300Bh: Usá siempre sizeof en las asignaciones de memoria dinámica, prefiriendo sizeof(*ptr)
      • Regla 0x300Ch: Verificá siempre los límites de los arreglos antes de acceder a sus elementos
      • Regla 0x300Dh: Utilizá enum en lugar de 'números mágicos' para conjuntos de estados y valores constantes
      • Regla 0x300Eh: Documentá explícitamente el comportamiento de las funciones al manejar punteros nulos como argumentos
      • Regla 0x300Fh: Liberá la memoria en el orden inverso a su asignación
      • Regla 0x3010h: Las variables que representan tamaños o índices de arreglos deben ser de tipo size_t
      • Regla 0x3011h: Si una función recibe un puntero genérico para operaciones de solo lectura, la firma de la función debe utilizar const void*
      • Regla 0x3012h: Prohibición de aritmética de punteros sobre void*
      • Regla 0x3013h: Asignación de memoria con sizeof sobre puntero en lugar del tipo apuntado
      • Regla 0x3014h: Prohibición de doble liberación de memoria (double free) sobre el mismo puntero
      • Regla 0x3015h: Reallocación segura: no sobreescribir el puntero original directamente
      • Regla 0x3016h: Orden incorrecto o sospechoso de argumentos en llamadas a memset
      • Regla 0x3017h: Orden canónico de calificadores: 'const tipo' en lugar de 'tipo const'
      • Regla 0x3018h: Inicialización idiomática de agregados con {0} en lugar de memset inmediato
      • Regla 0x3019h: Prohibición de comparar punteros contra constantes numéricas distintas de NULL o cero
      • Regla 0x301Ah: Validador de uso idiomático de tipos booleanos estándar
      • Regla 0x301Bh: Prohibición de casts de tipo innecesarios o redundantes
      • Regla 0x301Ch: Detector de variables locales no inicializadas con modificador const
      • Regla 0x301Dh: Diseñá los Tipos de Datos Abstractos utilizando punteros opacos
      • Regla 0x301Eh: Asigná NULL al puntero tras liberar un recurso opaco en el ámbito del cliente
      • Regla 0x301Fh: No compares numeros de punto flotante con igualdad exacta
  • Archivos y E/S (0x40XX)
    • Archivos y E/S (0x40XX)
    • Reglas (0x40XX)
      • Regla 0x4001h: Manejá correctamente la apertura y cierre de archivos
      • Regla 0x4002h: Validá los retornos de las operaciones de lectura y escritura de archivos
      • Regla 0x4003h: Utilizá errno, perror y strerror para reportar fallos del sistema operativo de manera precisa
      • Regla 0x4004h: Mantené la simetría de recursos al abrir y cerrar archivos en el mismo nivel de abstracción
      • Regla 0x4005h: Prescindí del uso de offsets y posiciones fijas codificadas a mano en archivos binarios sin validar sus dimensiones
      • Regla 0x4006h: Prohibición del antipatrón while (!feof(f)) para control de fin de archivo
      • Regla 0x4007h: Prohibición de rutas absolutas hardcodeadas en llamadas de archivo
      • Regla 0x4008h: Validación obligatoria del valor de retorno de fclose() en modo escritura
      • Regla 0x4009h: Prohibición de anidar llamadas a fopen() directamente dentro de funciones de E/S
      • Regla 0x400Ah: Prohibición de operar sobre flujos de archivo tras haber invocado fclose() (use-after-close)
      • Regla 0x400Bh: No uses fflush(stdin); consumi el buffer con getchar()
      • Regla 0x400Ch: Los formatos de printf/scanf deben coincidir y no ser variables
  • Compilacion, preprocesador y seguridad (0x50XX)
    • Compilacion, preprocesador y seguridad (0x50XX)
    • Reglas (0x50XX)
      • Regla 0x5001h: Los arreglos estáticos deben ser creados con un tamaño fijo en tiempo de compilación
      • Regla 0x5002h: Desarrollá y compilá siempre con todas las advertencias del compilador activadas
      • Regla 0x5003h: Utilizá guardas de inclusión en todos los archivos de cabecera
      • Regla 0x5004h: Todas las operaciones con cadenas deben ser seguras
      • Regla 0x5005h: Organizá la estructura de tus archivos .c de forma estándar
      • Regla 0x5006h: Preferí fgets sobre gets y scanf para leer cadenas
      • Regla 0x5007h: Inclusiones redundantes o duplicadas de la misma cabecera #include
      • Regla 0x5008h: Prohibición de funciones obsoletas o inseguras (gets, atoi)
      • Regla 0x5009h: Prohibición de división entera no intencional asignada a flotantes
      • Regla 0x500Ah: Protección obligatoria de parámetros en macros funcionales mediante paréntesis
      • Regla 0x500Bh: Inclusión obligatoria de cabeceras estándar para funciones de la biblioteca C
      • Regla 0x500Ch: Prohibición de inclusión directa de archivos de código fuente C (.c)
      • Regla 0x500Dh: Prohibición de redefinir palabras clave o tipos primitivos de C con #define
      • Regla 0x500Eh: Prohibición de la biblioteca obsoleta y no estándar <conio.h> (getch, clrscr)
      • Regla 0x500Fh: Colisión de nombres de macroguardas entre archivos de cabecera distintos
      • Regla 0x5010h: Prohibición de directivas #pragma no estándar o privativas
      • Regla 0x5011h: Prohibición de declaraciones extern en archivos de implementación (.c)
      • Regla 0x5012h: Detección de inclusiones cíclicas entre archivos de cabecera
      • Regla 0x5013h: Protección obligatoria con paréntesis envolventes en expresiones de macroconstantes (#define)
      • Regla 0x5014h: Inclusión explícita obligatoria de cabeceras para funciones de biblioteca estándar
      • Regla 0x5015h: No invoques el interprete de comandos con system() o popen()
  • Proceso, diseno y construccion sistematica (0x60XX)
    • Proceso, diseno y construccion sistematica (0x60XX)
    • Reglas (0x60XX)
      • Regla 0x6001h: Diseñá el algoritmo antes de escribir código en C
      • Regla 0x6002h: Compilá con frecuencia y resolvé el primer error antes de continuar
      • Regla 0x6003h: Declará cada variable lo más cerca posible de su primer uso
      • Regla 0x6004h: No reutilices una variable para propósitos distintos
      • Regla 0x6005h: No optimices prematuramente
  • Robustez y manejo de errores (0x70XX)
    • Robustez y manejo de errores (0x70XX)
    • Reglas (0x70XX)
      • Regla 0x7001h: Siempre debés inicializar las variables a un valor conocido
      • Regla 0x7002h: Validá los datos en la frontera del programa
      • Regla 0x7003h: No ignores valores de retorno que pueden indicar fallo
      • Regla 0x7004h: No llamés exit() en funciones de biblioteca: propagá el error
      • Regla 0x7005h: Inicializá todos los campos de estructuras y arreglos
      • Regla 0x7006h: Probá explícitamente los casos borde
      • Regla 0x7007h: Evitá los parámetros bandera de tipo bool
  • Verificacion, testing y depuracion (0x80XX)
    • Verificacion, testing y depuracion (0x80XX)
    • Reglas (0x80XX)
      • Regla 0x8001h: Una aserción por cada función de prueba
      • Regla 0x8002h: Escribí al menos una prueba por cláusula del contrato
      • Regla 0x8003h: Verificá con gcc, gdb y valgrind antes de entregar
      • Regla 0x8004h: Ejecutá la lista de verificación de calidad antes de entregar
• Manual del Ecosistema de Herramientas
  • Manual del Ecosistema de Herramientas Pedagógicas
  • 1. Autoría y Curaduría Pedagógica
    • Autoría y Curaduría Pedagógica
    • Manual de Referencia: alucarD
    • Manual de Referencia: corbel
    • Manual de Referencia: deckard
    • Manual de Referencia: idkfa
    • Manual de Referencia: keymaker
    • Manual de Referencia: moodle-toolbox
    • Manual de Referencia: myst-tools
    • Manual de Referencia: scorm-tools
    • Manual de Referencia: tyrell
  • 2. Desarrollo y Verificación
    • Desarrollo y Verificación
    • Manual de Referencia: bishop
    • Manual de Referencia: daedalus
    • Manual de Referencia: entorno
    • Manual de Referencia: gaff
    • Manual de Referencia: kaneda
    • Manual de Referencia: librerias-c
    • Manual de Referencia: nostromo
    • Manual de Referencia: ripley
    • Manual de Referencia: spunkmeyer
  • 3. Diagnóstico Forense y Runtime
    • Diagnóstico Forense y Runtime
    • Manual de Referencia: callahan
    • Manual de Referencia: dietrich
    • Manual de Referencia: hal
    • Manual de Referencia: tetsuo
    • Manual de Referencia: vasquez
    • Manual de Referencia: vassili
  • 4. Análisis Estático Especializado
    • Análisis Estático Especializado
    • Manual de Referencia: brett
    • Manual de Referencia: crowe
    • Manual de Referencia: drake
    • Manual de Referencia: ferro
    • Manual de Referencia: giger
    • Manual de Referencia: kane
    • Manual de Referencia: motoko
    • Manual de Referencia: parker
    • Manual de Referencia: rachel
    • Manual de Referencia: sebastian
    • Manual de Referencia: wierzbowski
    • Manual de Referencia: zhora
  • 5. Evaluación y Gestión Docente
    • Evaluación y Gestión Docente Masiva
    • Manual de Referencia: cyberdeck
    • Manual de Referencia: dredd
    • Manual de Referencia: gestion
    • Manual de Referencia: meet-tools
    • Manual de Referencia: p1-tools
    • Manual de Referencia: slide-tools
    • Manual de Referencia: weyl
• Repositorio de enunciados
  • Bloque 1: Fundamentos
    • Ejercicios Básicos y Secuencias
    • Ejercicios de Entrada y Salida Gradual
    • Ejercicios Matemáticos
    • Ejercicios: Testing, Variables Globales y Estructura de Código
    • Ejercicios: Control de Flujo
    • Ejercicios sobre Funciones
    • Ejercicios: Creación de Librerías de Funciones
    • Ejercicios: Compilación y Makefiles
    • Ejercicios: Refactorización de Código Ofuscado
  • Bloque 2: Memoria
    • Ejercicios de Punteros
    • Ejercicios de Punteros II
    • Ejercicios de Arreglos (Estáticos)
    • Ejercicios de Cadenas
    • Ejercicios de Archivos
    • Ejercicios Resueltos: Archivos de Texto
    • Ejercicios de Memoria Dinámica
    • Ejercicios de Gestión de Memoria Dinámica
    • Ejercicios Resueltos: Memoria Dinámica
    • Ejercicios de Memoria Dinámica Avanzada
    • Ejercicios de Estructuras
    • Ejercicios: Alias de Tipos
    • Ejercicios de enumeraciones
  • Bloque 3: Algoritmos y Estructuras de Datos
    • Ejercicios de matrices
    • Ejercicios: Tipos de Datos Abstractos
    • Ejercicios: Estructuras de Datos
    • Ejercicios de Análisis de Complejidad Algorítmica
  • Bloque 4: Temas Avanzados
    • Ejercicios: Punteros Avanzados y Genericidad
    • Ejercicios: Operaciones de Bits
    • Ejercicios: Archivos Binarios
    • Ejercicios: Recursividad y Divide y Vencerás
    • Ejercicios: Ordenamiento y Búsqueda
    • Ejercicios: Análisis de Código
    • Ejercicios de Diseño de Interfaces y Librerías en C
• Referencia
  • Índice de Referencia
  • Makefiles
  • La función printf
  • Biblioteca Estándar de C
  • Decálogo de Algoritmos de Busqueda y Ordenamiento
  • Refactorización
    • Único Retorno
    • Técnicas de Simulación de Estructuras de Control
    • Eliminación de Números Mágicos
    • Extracción de Funciones
    • Simplificación de Condicionales
    • Refactorización de Variables y Alcance
    • Mejora de Nombres y Comunicación de Intenciones
    • Refactorización de Código Duplicado
• Guías
  • Índice de Guías
  • Bash para empezar
  • Guía git base
  • Guía git avanzada
  • Uso de GitHub en la Cátedra
  • Manual del Entorno de Desarrollo Portable
  • Documentación con Doxygen
  • Guía de Markdown (GitHub Flavored)
  • Guía completa de Visual Studio Code
  • Herramientas de Desarrollo para C
  • Guía completa de GCC
  • Lógica Proposicional para Programación
  • Inteligencia Artificial Generativa para Reforzar el Aprendizaje
• Bibliografia
  • Recursos

Tabla de reglas¶