Aprendiendo a Testear APIs - Postman

Aprendiendo a Testear APIs - Postman

Testing Para Todos

Why SHOULD You Learn API Testing? 📬 | #1

https://www.youtube.com/watch?v=w0dRuyKQW3M

Domina las Partes del Request a una API | # 2

https://www.youtube.com/watch?v=ANP4s02Lkhw

How to Use Postman to Test APIs (Practical) | #3

https://www.youtube.com/watch?v=AtRBTki2oeY

 

Qué hacer después de instalar Linux Mint 22.2

 

https://notilinux.com/que-hacer-despues-de-instalar-linux-mint-22-2/ 

PorMauro diciembre 4, 2025

Linux Mint 22.2 es una de esas distribuciones que te hacen sentir en casa desde el primer minuto. Su escritorio Cinnamon sigue siendo ligero, moderno y tremendamente práctico, pero como siempre pasa en Linux, hay varias cosas que conviene ajustar, instalar y optimizar para dejar el sistema realmente listo para trabajar, estudiar o simplemente disfrutar del día a día.

En esta guía te voy a mostrar paso a paso qué hacer después de instalar Linux Mint 22.2, basándome en la experiencia real de uso y en esos ajustes que verdaderamente marcan la diferencia. Nada de cosas rebuscadas: solo lo que necesita un usuario real.

1. Actualizar el sistema por completo

Aunque Mint ya viene muy pulido, lo primero es actualizar todos los paquetes:

sudo apt update && sudo apt upgrade -y

sudo apt update && sudo apt upgrade -y

También podés actualizar directamente desde la herramienta Administrador de actualizaciones, pero siempre recomiendo hacerlo por terminal para asegurarte de que todo queda realmente al día.

2. Instalar controladores (especialmente NVIDIA)

Mint hace un gran trabajo detectando drivers, pero si tenés una placa NVIDIA o hardware de Wi-Fi/Bluetooth extraño, conviene revisar:

Menú → Administración → Controladores adicionales

Elegí siempre el driver propietario recomendado. En NVIDIA suele ser el que mejor rendimiento da con juegos, OBS, edición de video y demás.

3. Activar la aceleración con Vulkan y herramientas gaming

Aunque no seas gamer, Vulkan le da una mejora interesante al sistema. Instalalo con:

sudo apt install mesa-vulkan-drivers vulkan-tools

sudo apt install mesa-vulkan-drivers vulkan-tools

Si sos gamer, también podés instalar soporte adicional:

sudo apt install gamemode

sudo apt install gamemode

4. Habilitar el modo de limpieza automática

Mint permite activar un sistema de mantenimiento inteligente para borrar kernels viejos, paquetes huérfanos y caches:

Menú → Administración → Administrador de actualizaciones → Automatización

Habilitá:

• Eliminar kernels obsoletos
• Limpiar paquetes residuales
• Instalar actualizaciones de seguridad automáticamente

5. Elegir un tema moderno y cómodo

Cinnamon 6.x incluye mejoras visuales, pero Mint viene con un estilo conservador. Si querés darle un toque más moderno:

Menú → Configuración del sistema → Temas

Probá “Mint-Y-Dark”, o los nuevos colores. También podés activar el escritorio en modo oscuro completo.

6. Optimizar el rendimiento general

Si querés un Mint más rápido y fresco, aplicá estas mejoras:

💾 Habilitar zRAM

Mint 22 ya trae zRAM activado, pero podés verificarlo:

systemctl status zramswap

systemctl status zramswap

🔧 Instalar herramientas de rendimiento

Preload acelera la apertura de apps:

sudo apt install preload

sudo apt install preload

Y si tenés SSD (seguramente sí), activá TRIM en modo automático:

sudo systemctl enable fstrim.timer
sudo systemctl start fstrim.timer

sudo systemctl enable fstrim.timer
sudo systemctl start fstrim.timer

7. Mejorar la seguridad básica

Mint no incluye firewall activado por defecto. Podés encenderlo con:

sudo ufw enable

sudo ufw enable

Ver estado:

sudo ufw status

sudo ufw status

8. Instalar software esencial (APT / Flatpak / Snap)

Mint 22.2 usa APT y Flatpak como sistemas principales. Snap está disponible, aunque deshabilitado por Canonical — podés habilitarlo si querés.

Antes de instalar apps vía Flatpak, podés leer nuestras guías completas:

• Guía definitiva de Flatpak
• Guía definitiva de Snap

A continuación, te dejo las aplicaciones más recomendadas:

🎨 GIMP

sudo apt install gimp
flatpak install flathub org.gimp.GIMP

sudo apt install gimp
flatpak install flathub org.gimp.GIMP

📺 VLC

sudo apt install vlc
flatpak install flathub org.videolan.VLC

sudo apt install vlc
flatpak install flathub org.videolan.VLC

🎥 OBS Studio

sudo apt install obs-studio
flatpak install flathub com.obsproject.Studio

sudo apt install obs-studio
flatpak install flathub com.obsproject.Studio

🎮 Steam

sudo apt install steam
flatpak install flathub com.valvesoftware.Steam

sudo apt install steam
flatpak install flathub com.valvesoftware.Steam

🛠 Timeshift

sudo apt install timeshift

sudo apt install timeshift

9. Aplicaciones recomendadas para Linux Mint 22.2

Además de las anteriores, estas apps son muy útiles en el día a día:

• Telegram Desktop
• Inkscape
• LibreOffice (versión Flatpak más actualizada)
• Warpinator (transferencia entre dispositivos)
• BleachBit (limpieza avanzada)

Enlaces útiles de Linux Mint

• Sitio oficial: https://linuxmint.com
• Descargas oficiales: https://linuxmint.com/download.php
• Foro oficial: https://forums.linuxmint.com
• Blog de desarrollo: https://blog.linuxmint.com

Documentación recomendada

• Manual oficial de usuario: https://linuxmint.com/documentation.php
• Guía de Instalación: https://linuxmint-installation-guide.readthedocs.io/en/latest/
• Información de la Versión: https://linuxmint.com/rel_zara.php

Conclusión

Linux Mint 22.2 es una de las mejores experiencias para quienes buscan un sistema estable, rápido y familiar, pero con toda la libertad que ofrece Linux. Después de aplicar estos pasos vas a tener un Mint optimizado, seguro, con drivers correctos, buen rendimiento y todas las aplicaciones necesarias para comenzar a trabajar desde el primer día.

Disfrutá de tu nuevo sistema y, como siempre, si querés seguir profundizando podés explorar nuestros otros artículos de NotiLinux. ¡A seguir linuxeando! 🐧

 

MicroPython en tu ESP32 usando Thonny IDE

 MicroPython en tu ESP32 usando Thonny IDE

Para montar MicroPython en tu ESP32 usando Thonny IDE desde Linux, el proceso es muy visual y automático. Thonny ya incluye las herramientas necesarias para borrar la memoria de la placa y descargar el firmware oficial.

Sigue estos pasos detallados para instalarlo y dejarlo listo:

1. Preparar los permisos en Linux

Antes de abrir Thonny, asegúrate de que tu usuario de Linux tenga permiso para leer y escribir en los puertos USB. Abre una terminal en tu Linux y ejecuta:

sudo usermod -a -G dialout $USER

(Nota: Para que este cambio tenga efecto, debes cerrar sesión en Linux y volver a entrar, o reiniciar el sistema).

---

2. Pasos para instalar MicroPython desde Thonny

1. Conecta tu ESP32 a la computadora mediante un cable USB (asegúrate de que sea un cable de datos y no solo de carga). [1]
2. Abre Thonny.
3. Ve al menú superior y selecciona Herramientas (Tools) > Opciones (Options).
4. Haz clic en la pestaña Intérprete (Interpreter).
5. En el primer menú desplegable, selecciona: MicroPython (ESP32). [2]
6. En el segundo desplegable (Puerto/Port), selecciona el puerto donde está tu placa (normalmente aparece como /dev/ttyUSB0 o /dev/ttyACM0).
7. En la esquina inferior derecha de esa misma ventana, haz clic en las letras azules que dicen Instalar o actualizar MicroPython (Install or update MicroPython).
8. Se abrirá una pequeña ventana flotante:
   • Target port: Elige tu puerto /dev/ttyUSB0.
   • Family: Selecciona ESP32 (o ESP32 / WROOM según tu modelo).
   • Variant: Selecciona la estándar (la que dice solo Expressif ESP32).
   • Version: Deja la versión recomendada que Thonny te ofrece por defecto. [3]
9. Haz clic en el botón Instalar (Install).

💡 Nota Importante: Thonny se conectará a internet, descargará el archivo .bin oficial, borrará la memoria de la ESP32 (Flash) e instalará el sistema de forma automática. Tardará cerca de un minuto.

---

3. Verificar que funciona

Una vez que termine el proceso, cierra las ventanas de configuración. Mira la parte inferior de Thonny, en la sección llamada Terminal (Shell).

Verás un mensaje de bienvenida y el prompt clásico de MicroPython:

MicroPython v1.2X.X on 2026-XX-XX; ESP32 module with ESP32
Type "help()" for more information.
>>> 

Si escribes print("Hola desde ESP32") y presionas Enter, la placa te responderá inmediatamente. Desde este momento, cualquier archivo de código que guardes en Thonny te dará la opción de almacenarlo directamente dentro de la memoria de la ESP32.

¿Pudiste completar la instalación de esta manera, o te arrojó algún error de conexión o puerto al intentar flashearla?

[1] https://docs.sunfounder.com

[2] https://docs.sunfounder.com

[3] https://docs.sunfounder.com

 

Comandos Esenciales de MicroPython para ESP32

 

Comandos Esenciales de MicroPython para ESP32

 

Aquí tienes una tabla con los comandos esenciales para trabajar en la consola (REPL) de MicroPython en tu ESP32. Están organizados por categorías funcionales para que puedas usarlos de referencia rápida.

Comandos Esenciales de MicroPython para ESP32

Categoría	Comando en MicroPython	Descripción / Acción
Ayuda y Sistema	help()	Muestra información básica y ayuda del sistema.
	import gc; gc.collect(); gc.mem_free()	Libera memoria RAM basura y muestra los bytes libres.
	import machine; machine.reset()	Reinicia por completo la ESP32 (Hard Reset).
	import machine; machine.freq()	Muestra la frecuencia actual del reloj (normalmente 160MHz o 240MHz).
Archivos y Directorios	import os; os.listdir()	Lista todos los archivos dentro de la memoria de la ESP32 (como ls).
	os.mkdir('nombre_carpeta')	Crea una nueva carpeta en el almacenamiento.
	os.chdir('nombre_carpeta')	Cambia el directorio de trabajo actual (como cd).
	os.remove('archivo.py')	Elimina un archivo específico (como rm).
	os.stat('archivo.py')	Muestra el tamaño en bytes y metadatos del archivo.
Lectura/Escritura de Archivos	f = open('boot.py', 'r'); print(f.read()); f.close()	Lee y muestra el contenido de un archivo en pantalla (como cat).
	f = open('test.py', 'w'); f.write('print("Hola")'); f.close()	Crea o sobreescribe un archivo escribiendo texto en él.
Control de Pines (GPIO)	from machine import Pin	Importa la librería necesaria para controlar los pines físicos.
	led = Pin(2, Pin.OUT)	Configura el Pin 2 (suele ser el LED azul integrado) como salida.
	led.value(1) o led.on()	Enciende el pin (pone el voltaje en alto, 3.3V).
	led.value(0) o led.off()	Apaga el pin (pone el voltaje en bajo, 0V).
	boton = Pin(4, Pin.IN, Pin.PULL_UP)	Configura el Pin 4 como entrada con resistencia Pull-Up.
	boton.value()	Lee el estado del pin (devuelve 1 o 0).
Señales Analógicas y PWM	from machine import ADC; adc = ADC(Pin(34))	Configura el Pin 34 para leer voltajes analógicos (0 a 3.3V).
	adc.read_uv()	Lee el voltaje del pin analógico directamente en microvoltios.
	from machine import PWM; pwm = PWM(Pin(2), freq=1000, duty_u16=32768)	Genera una señal PWM (para atenuar luces o mover servos).
Redes y Wi-Fi	import network; wlan = network.WLAN(network.STA_IF)	Inicializa la interfaz de red en modo estación (cliente).
	wlan.active(True)	Enciende la antena Wi-Fi de la ESP32.
	wlan.scan()	Escanea las redes Wi-Fi al alcance y muestra sus datos.
	wlan.connect('SSID', 'PASSWORD')	Se conecta a tu red Wi-Fi local.
	wlan.isconnected()	Devuelve True si la conexión Wi-Fi es exitosa.
	wlan.ifconfig()	Muestra la dirección IP asignada, máscara, puerta de enlace y DNS.

---

Atajos útiles de teclado en la consola (REPL) desde Linux

Cuando estés conectado por tio, screen o WebREPL, estos atajos te ahorrarán mucho tiempo:

• Ctrl + C: Interrumpe el programa que se esté ejecutando en ese momento y te devuelve la línea de comandos.
• Ctrl + D: Realiza un reinicio suave (Soft Reset) del software. Recarga los archivos boot.py y main.py al instante.
• Ctrl + E: Activa el Modo Pegado (Paste Mode). Ideal para copiar códigos largos desde tu Linux y pegarlos en la consola sin que se rompa la indentación. Presionas Ctrl + D para terminar de pegar y ejecutar.

¿Te gustaría que diseñemos un script para automatizar el parpadeo de un LED al arrancar, o prefieres ver cómo enviar datos de sensores a través de la red?

 

ESP32 consola comandos acceder por Wi-Fi a MicroPython WebREPL o configurando una terminal por Telnet/SSH.

 ESP32 consola comandos acceder por Wi-Fi a MicroPython WebREPL o configurando una terminal por Telnet/SSH.

 

Sí, se puede acceder por Wi-Fi a MicroPython de forma completamente inalámbrica. Puedes hacerlo mediante una consola interactiva en el navegador web (WebREPL) o configurando una terminal por Telnet/SSH. [1]

Aquí tienes los pasos exactos para activar el acceso inalámbrico:

Opción 1: WebREPL (La oficial y más segura)

MicroPython incluye una herramienta oficial llamada WebREPL que te permite abrir la consola y transferir archivos desde cualquier navegador web en tu Linux.

1. Conéctate por primera vez por cable serial y ejecuta este comando para configurarlo:

   import webrepl_setup
   

2. Sigue las instrucciones en pantalla:
   • Presiona E para habilitarlo (enable).
   • Define una contraseña de acceso (4 a 9 caracteres).
   • Reinicia la ESP32 cuando te lo pida.
3. Conecta la ESP32 a tu red Wi-Fi. Para que se conecte automáticamente al arrancar, crea o edita el archivo boot.py en la ESP32 con este código:

   import network
   import webrepl
   
   wlan = network.WLAN(network.STA_IF)
   wlan.active(True)
   if not wlan.isconnected():
       print('Conectando a la red...')
       wlan.connect('NOMBRE_DE_TU_WIFI', 'CONTRASEÑA_DE_TU_WIFI')
       while not wlan.isconnected():
           pass
   print('Configuración de red:', wlan.ifconfig())
   
   # Inicia el servicio inalámbrico
   webrepl.start()
   

   [2]
4. Accede desde tu Linux:
   • Anota la dirección IP que te dio el código anterior (ej. 192.168.1.50).
   • Abre en tu navegador Linux el cliente oficial: micropython.org
   • Cambia la IP en el cuadro de texto (ej. ws://192.168.1.50:8266/) y haz clic en Connect.
   • Introduce la contraseña que creaste en el paso 1. ¡Listo!

---

Opción 2: Telnet tradicional (Para usar tu terminal de Linux)

Si prefieres usar comandos puros en la terminal de tu Linux (telnet o netcat) en lugar de un navegador web, puedes levantar un servidor de sockets manual en la ESP32 que redirija la consola.

Para ello, una vez conectada la ESP32 al Wi-Fi, ejecuta este script en la placa para redirigir la entrada/salida a la red:

import os
import socket

# Crear un servidor en el puerto 23 (Telnet)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
print("Esperando conexión Telnet...")

conn, addr = s.accept()
# Redirigir la consola interactiva (REPL) al socket de red
os.dupterm(conn)

Luego, desde la terminal de tu computadora Linux, simplemente ejecutas:

telnet 192.168.1.50 23

---

¿Qué método prefieres implementar? Si quieres, te puedo ayudar a escribir el script completo para automatizar la conexión Wi-Fi o mostrarte cómo subir archivos .py de forma remota usando la herramienta mpremote.

[1] https://www.ctaelectronics.com

[2] https://www.maquinasvirtuales.eu

 

ESP32 consola interactiva estilo Unix con comandos como ls, cd, control de pines y red - Solución MicroPython

 ESP32 consola interactiva estilo Unix con comandos como ls, cd, control de pines y red - Solución MicroPython

 

Para un ESP32, la opción más práctica y madura con consola interactiva estilo Unix (con comandos como ls, cd, control de pines y red) es MicroPython. No es un Linux completo, pero em funciona como un micro-SO con REPL (consola interactiva en Python) accesible por puerto serial (/dev/ttyUSB0 o /dev/ttyACM0) desde tu otro equipo Linux usando herramientas como screen o tio. [1, 2, 3, 4]

Aquí te detallo las mejores alternativas de "micro-SO / shells" según lo que busques:

1. MicroPython (La opción más recomendada)

• Qué es: Un intérprete de Python optimizado para microcontroladores que expone una consola interactiva directa.
• Por qué elegirlo: Te da acceso inmediato a una línea de comandos en la ESP32 apenas enciendes el dispositivo. Puedes importar librerías, inspeccionar memoria, leer pines GPIO y programar lógica al vuelo sin compilar código en C.
• Cómo conectarte desde Linux: Conectas la ESP32 por USB y usas en tu terminal de Linux:

  sudo usermod -a -G dialout $USER  # (Solo la primera vez para permisos de puerto)
  tio /dev/ttyUSB0 -b 115200
  

  [1, 5, 6, 7, 8]

2. Esp32OS o MiniOS-ESP (Entornos estilo Unix sobre FreeRTOS)

• Qué es: Proyectos de código abierto como Esp32OS o MiniOS-ESP.
• Por qué elegirlo: Implementan un shell estilo Linux (con comandos tipo ls, cd, cat, manejo de tareas y control de hardware) corriendo sobre FreeRTOS. Muchos soportan acceso dual por consola serial UART y por Telnet a través de Wi-Fi. [9, 10, 11]

---

¿Cómo flashear y acceder desde tu Linux principal?

1. Instala la herramienta de flasheo en tu Linux:

   pip install esptool
   

2. Descarga el firmware .bin oficial desde la web de MicroPython.
3. Borra la flash e instala el micro-SO:

   esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
   esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-firmware.bin
   

4. Abre la consola serial con screen, minicom o tio a 115200 baudios y verás el prompt >>> listo para usarse. [6, 12, 13, 14]

Para ayudarte a dar el siguiente paso de la mejor manera, ¿te gustaría conocer los comandos básicos para controlar los pines GPIO desde esa consola o prefieres saber cómo configurarlo para acceder de forma inalámbrica vía Wi-Fi/Telnet?

¿Te gustaría saber cómo controlar los pines GPIO desde la consola o prefieres configurar el acceso por Wi-Fi (Telnet) desde tu Linux?

[1] https://forum.arduino.cc

[2] https://learn.adafruit.com

[3] https://github.com

[4] https://atareao.es

[5] https://www.youtube.com

[6] https://blesplo.it

[7] https://www.esploradores.com

[8] https://inamata.io

[9] https://github.com

[10] https://github.com

[11] https://www.reddit.com

[12] https://www.youtube.com

[13] https://www.luisllamas.es

[14] https://intesc.mx

 

que framework proramando me recomiendas para realizar bancos de preguntas y poner a estudiantes a presentar de acuerdo a un spreadsheet con # id nombres y apellidos, correos

 

 

 

Si quieres programar tu propia solución a medida para tener control total y costo cero en servidores, la mejor combinación del mundo es usar Next.js (React) con TypeScript en el frontend, y conectar todo mediante una API de Google Sheets como tu base de datos de alumnos y preguntas.

Para un despliegue rápido y escalable, el ecosistema ideal que te recomiendo es el siguiente:

El Stack Técnico Recomendado

• Framework Principal: Next.js (React) con TypeScript. Te da rutas protegidas rápidas, renderizado del lado del servidor para validar accesos, y tipado estricto para evitar errores con las preguntas.
• Base de Datos y Datos de Alumnos: Google Sheets API. No necesitas configurar PostgreSQL o MongoDB. Usas la hoja de cálculo existente con ID, Nombres, Apellidos y Correos como tu base de datos en tiempo real.
• Estilos y UI: Tailwind CSS + shadcn/ui. Te permite diseñar interfaces limpias, adaptables a celulares y con componentes listos (como temporizadores o tarjetas de preguntas).
• Procesamiento de Fórmulas Matemáticas: KaTeX o MathJax. Librerías ligeras de JavaScript para renderizar perfectamente el código LaTeX de tus preguntas de matemáticas en el navegador.

---

Arquitectura de la Solución (Cómo estructurarlo)

[ Google Sheets ] ──(API)──> [ Next.js Backend (API Routes) ] ──> [ Frontend del Estudiante ]
  - Pestaña 1: Alumnos          - Valida el Correo/ID.              - Muestra las 20 preguntas.
  - Pestaña 2: 200 Preguntas    - Mezcla y selecciona 20 de 200.    - Envía las respuestas al Sheets.

1. Autenticación sin contraseñas: El estudiante ingresa su correo. Tu servidor Next.js consulta la pestaña Alumnos del Spreadsheet. Si el correo existe, le permite iniciar el examen.
2. Algoritmo de Aleatoriedad (Backend): Para evitar que los alumnos hagan trampa inspeccionando el código del navegador, las 200 preguntas se procesan en el servidor. Tu backend hace un Fisher-Yates shuffle a la lista, extrae solo 20 y se las envía al frontend.
3. Guardado de Notas: Cuando el alumno da clic en "Enviar", el sistema calcula la nota y usa la API de Google Sheets para escribir el resultado directamente en una fila al lado del nombre del alumno.

---

Archivo Base de Configuración

Para que empieces a programar ya mismo, he generado un archivo comprimido que contiene la estructura inicial de la base de datos de alumnos en formato CSV, junto con el script base en TypeScript (utils/quiz.ts) que procesa la selección aleatoria de las 20 preguntas de forma segura.

Aquí está tu archivo: banco_preguntas_base.zip.
Este archivo contiene:

• alumnos_template.csv: Plantilla con las columnas id, nombres, apellidos, correo listos para subir a tu Google Sheets.
• quiz.ts: Código fuente en TypeScript con la función algorítmica para mezclar las preguntas eficientemente en el servidor sin repetir elementos.

El código clave en TypeScript que debes usar en tus rutas de Next.js para segmentar las preguntas es el siguiente:

export interface Pregunta {
  id: number;
  enunciado: string;
  opciones: string[];
  respuestaCorrecta: string;
}

// Algoritmo Fisher-Yates para aleatoriedad real
export function obtenerPreguntasAleatorias(banco: Pregunta[], cantidad = 20): Pregunta[] {
  const arreglo = [...banco];
  for (let i = arreglo.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [arreglo[i], arreglo[j]] = [arreglo[j], arreglo[i]];
  }
  return arreglo.slice(0, cantidad);
}

¿Prefieres que te ayude a escribir el código para conectar Next.js directamente con la API de Google Sheets, o te gustaría ver cómo estructurar el componente del temporizador en React para el examen?