Simulador De Sistemas Operativos Con Tkinter

Orden obligatorio:

1. Implementar algoritmos en consola con casos de prueba validados
2. Crear UI mínima funcional
3. Iteraciones incrementales agregando funcionalidad
4. Polish visual al final

Prohibición crítica: NO diseñar la UI completa antes de tener la lógica funcional.

Métrica: Dedicar 50% del tiempo total a la Fase 1 (algoritmos en consola).

📋 REGLA 3: Manejo Asíncrono con Tkinter - Método after()

Obligatorio:

• ✅ Usar root.after(ms, callback) para actualizaciones periódicas
• ✅ Frecuencias recomendadas:
  • CPU/RAM: cada 1000 ms
  • Disco: cada 3000 ms
  • Procesos: cada 2000 ms

Prohibiciones absolutas:

• ❌ NO usar time.sleep() en callbacks de Tkinter (bloquea toda la UI)
• ❌ NO usar while True en el hilo principal
• ❌ NO usar threading en nivel fácil (usar after() recursivo)
• ❌ NO llamar psutil.cpu_percent(interval=1.0) en callbacks directos

Patrón correcto:

def update_dashboard(self):
    # Actualizar widgets
    cpu = psutil.cpu_percent(interval=0.1)
    self.cpu_label.config(text=f"CPU: {cpu}%")
    
    # Programar próxima actualización (recursivo)
    self.after_id = self.after(1000, self.update_dashboard)

📋 REGLA 4: Sistema de Archivos Virtual - 100% En Memoria

Requisitos:

• ✅ Todo el FS debe residir en estructuras de datos (diccionarios)
• ✅ Nunca usar open(), os.remove(), o cualquier operación real de disco
• ✅ Persistencia opcional solo con json.dump() al cerrar la aplicación

Peligro crítico: Tocar el FS real del sistema host puede causar pérdida de datos.

📋 REGLA 5: Arquitectura de Carpetas Simplificada

ProySistemasOperativos/
├── main.py                     # Punto de entrada
├── requirements.txt            # Solo psutil==5.9.8
├── README.md                   
├── core/
│   ├── __init__.py
│   ├── process.py              # Clase Process
│   ├── scheduler.py            # Scheduler + FIFO/SJF/RoundRobin
│   ├── file_system.py          # Directory y File simulados
│   ├── system_monitor.py       # Funciones con psutil
│   ├── test_scheduler.py       # Pruebas consola
│   ├── test_monitor.py         # Pruebas monitoreo
│   └── test_file_system.py     # Pruebas FS
└── gui/
    ├── __init__.py
    └── app.py                  # Clase App(tk.Tk) - toda la interfaz

Notas:

• NO hay carpeta monitor/ separada (simplicidad)
• NO hay carpeta controllers/ (un solo archivo app.py en nivel fácil)
• NO hay carpeta resources/ (no se usa Qt Designer)

📋 REGLA 6: Algoritmos de Planificación

Clases requeridas:

• Scheduler (clase base con interfaz común)
• FIFOScheduler → listas simples o queue.Queue
• SJFScheduler → sorted() por burst_time
• RoundRobinScheduler → listas con quantum configurable (default=2.0)

Interfaz obligatoria:

add_process(process: Process) -> None
run() -> List[Dict]  # Timeline: [{"pid": 1, "start": 0, "end": 5, "state": "running"}, ...]
get_statistics() -> Dict  # {"waiting_time_avg": ..., "turnaround_time_avg": ...}

📋 REGLA 7: Testing Obligatorio por Fase

Scripts de prueba mínimos:

• core/test_scheduler.py → validar los 3 algoritmos en consola
• core/test_monitor.py → imprimir CPU/RAM cada 2 segundos
• core/test_file_system.py → probar crear/listar archivos y carpetas

Checklist de hitos evaluables:

• ✅ Semana 2: Timeline correcto de FIFO/SJF/RR en consola
• ✅ Semana 3: Monitoreo de CPU%/RAM% actualizándose
• ✅ Semana 4: FS simulado con operaciones básicas
• ✅ Semana 5: Ventana con ttk.Notebook y 3 pestañas vacías
• ✅ Semana 6: Dashboard con Progressbar actualizándose sin bloquear UI
• ✅ Semana 7: Timeline de Gantt en Canvas funcional
• ✅ Semana 8: Aplicación completa + README.md

📋 REGLA 8: Componentes GUI Requeridos

Ventana principal (tk.Tk):

• Título: "Simulador de Sistemas Operativos - UAGRM"
• Dimensiones fijas: 1000x700 pixels

Menu superior (tk.Menu):

• Archivo → Salir
• Ayuda → Acerca de

Notebook con pestañas (ttk.Notebook):

Pestaña 1: "Dashboard"

• Frame CPU: Label + ttk.Progressbar para uso de CPU
• Frame RAM: Label + ttk.Progressbar para uso de RAM
• Frame Disco: ttk.Treeview para mostrar particiones

Pestaña 2: "Planificadores"

• Frame izquierdo:
  • ttk.Combobox para seleccionar algoritmo (FIFO, SJF, Round Robin)
  • ttk.Entry para quantum (visible solo si Round Robin)
  • Botón "Agregar Proceso"
  • ttk.Treeview para lista de procesos pendientes
• Frame derecho:
  • Canvas para timeline de Gantt (rectángulos coloreados por PID)
  • Label para estadísticas
  • Botón "Ejecutar Simulación"

Pestaña 3: "Sistema de Archivos"

• ttk.Treeview para estructura de directorios
• Frame inferior con botones: "Crear Archivo", "Crear Carpeta", "Actualizar"

⚠️ ERRORES CRÍTICOS QUE CAUSAN FRACASO

1. Bloqueo de interfaz con sleep o bucles

Error: Usar time.sleep() dentro de callbacks o while True en hilo principal
Solución: Siempre usar root.after(ms, callback) para actualizaciones periódicas

2. Actualización fuera del hilo principal

Error: Crear threading.Thread para monitoreo y actualizar widgets directamente
Solución: En nivel fácil, evitar threading. Usar after() con intervalos cortos (1000ms)

3. Fugas de memoria con after recursivo

Error: Llamar after() sin condición de parada al cerrar ventana
Solución: En método de cierre, cancelar con after_cancel(id)

4. Canvas sin escalado para timeline

Error: Dibujar timeline con coordenadas fijas que se salen del Canvas
Solución: Calcular escala dinámica: pixels_por_segundo = ancho_canvas / duracion_total

5. Mezcla de lógica y presentación

Error: Escribir algoritmos de planificación dentro de métodos de la clase App
Solución: Mantener core/scheduler.py 100% independiente. App solo llama a scheduler.run() y muestra resultados

🎯 Estrategia de Desarrollo Recomendada

Fase 1 - Prioridad Absoluta (Semanas 1-2)

• Dedica 10 días completos solo a core/scheduler.py
• Valida cada algoritmo con al menos 3 casos de prueba diferentes
• Si un algoritmo falla en consola, NO avances a GUI

Fase 2 - Prototipo Mínimo GUI (Semana 5)

• Día 1: Ventana Tkinter vacía con título
• Día 2: Agregar ttk.Notebook con 3 pestañas vacías
• Día 3: En Dashboard, agregar solo 1 Label que diga "CPU: 0%"
• Día 4: Conectar Label a psutil.cpu_percent() con after(1000, ...)
• Día 5: Agregar Progressbar junto al Label

Fase 3 - Timeline de Gantt (Semana 7)

1. Canvas blanco de 800x200 pixels
2. Dibujar UN rectángulo estático con create_rectangle()
3. Dibujar rectángulo basado en datos de UN proceso
4. Dibujar múltiples rectángulos para timeline completo

Nunca intentar dibujar el timeline completo en el primer intento

Gestión de Tiempo Realista

• Semanas 1-2: 70% algoritmos, 30% documentación
• Semanas 3-4: 50% monitoreo + FS, 50% pulir algoritmos
• Semanas 5-6: 30% GUI básica, 70% conectar lógica
• Semanas 7-8: 80% integración, 20% polish visual

📝 Criterio de Éxito Académico

Proyecto aprobatorio:

• ✅ Algoritmos correctos (validados en consola)
• ✅ Dashboard que muestra CPU/RAM actualizándose
• ✅ Timeline de Gantt legible (aunque simple)

Proyecto reprobatorio:

• ❌ Interfaz "bonita" pero algoritmos incorrectos

🔧 Entorno Virtual Obligatorio

Pasos obligatorios:

1. Verificar Python: python --version (debe ser 3.11.x)
2. Crear entorno: python -m venv venv
3. Activar: venv\Scripts\activate (Windows)
4. Instalar: pip install -r requirements.txt
5. Inicializar Git: git init

Advertencia: Saltar esta configuración causa problemas de dependencias.

📚 Referencias Rápidas

Primera llamada a psutil:

# Inicialización (hacer una vez al inicio)
psutil.cpu_percent(interval=0.1)

# Luego en actualizaciones:
cpu = psutil.cpu_percent(interval=None)  # No bloquea

Patrón after recursivo:

def update(self):
    # Actualizar widgets aquí
    self.after_id = self.after(1000, self.update)

def on_close(self):
    if hasattr(self, 'after_id'):
        self.after_cancel(self.after_id)
    self.destroy()

Timeline en Canvas:

# Escala dinámica
pixels_per_second = canvas_width / total_duration

# Dibujar proceso
x1 = start_time * pixels_per_second
x2 = end_time * pixels_per_second
canvas.create_rectangle(x1, y, x2, y+30, fill=color_by_pid[pid])
canvas.create_text((x1+x2)//2, y+15, text=f"P{pid}")

Este plan es realista para 8 semanas con 8-10 horas semanales. La simplicidad de Tkinter permite enfocarse en los conceptos de Sistemas Operativos sin perder tiempo en complejidades de frameworks GUI.

Prioriza corrección lógica sobre apariencia visual.