Autoría y Curaduría Pedagógica
Herramientas destinadas al diseño, composición, validación y empaquetado de ejercicios, guías de trabajos prácticos, exámenes y materiales de lectura.
Herramientas destinadas al diseño, composición, validación y empaquetado de ejercicios, guías de trabajos prácticos, exámenes y materiales de lectura.
- Programación 1
- Cátedra
- Apunte
- Índice del Apunte
- Bloque 1: Fundamentos
- Bloque 2: Memoria
- Bloque 3: Algoritmos y Estructuras de Datos
- 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)
- 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
- 3. Diagnóstico Forense y Runtime
- 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
- 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
- Bloque 4: Temas Avanzados
- Bloque 1: Fundamentos
- Referencia
- 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