diff --git a/Roadmap/25 - LOGS/java/eulogioep.java b/Roadmap/25 - LOGS/java/eulogioep.java
new file mode 100644
index 0000000000..f8f2abad0d
--- /dev/null
+++ b/Roadmap/25 - LOGS/java/eulogioep.java	
@@ -0,0 +1,218 @@
+/**
+ * Implementación de un sistema de logging y gestión de tareas en Java.
+ * 
+ * TEORÍA SOBRE LOGGING EN JAVA:
+ * Java proporciona un framework de logging nativo (java.util.logging) que ofrece:
+ * - Diferentes niveles de severidad (SEVERE, WARNING, INFO, etc.)
+ * - Capacidad de escribir en múltiples destinos (consola, archivo)
+ * - Formato personalizable de mensajes
+ * - Filtros y handlers configurables
+ * 
+ * Niveles de logging en java.util.logging:
+ * - SEVERE: Para errores críticos
+ * - WARNING: Para advertencias
+ * - INFO: Para información general
+ * - CONFIG: Para mensajes de configuración
+ * - FINE, FINER, FINEST: Para depuración con diferentes niveles de detalle
+ */
+
+ import java.io.IOException;
+ import java.time.LocalDateTime;
+ import java.time.format.DateTimeFormatter;
+ import java.util.ArrayList;
+ import java.util.List;
+ import java.util.logging.*;
+ import java.util.stream.Collectors;
+ 
+ public class eulogioep {
+     /**
+      * Clase para manejar el logging personalizado
+      */
+     static class CustomLogger {
+         private static final Logger LOGGER = Logger.getLogger(CustomLogger.class.getName());
+         
+         static {
+             try {
+                 // Configurar el logger para escribir en un archivo
+                 FileHandler fileHandler = new FileHandler("tareas.log", true);
+                 fileHandler.setFormatter(new SimpleFormatter());
+                 LOGGER.addHandler(fileHandler);
+                 
+                 // Configurar el logger para escribir en consola
+                 ConsoleHandler consoleHandler = new ConsoleHandler();
+                 consoleHandler.setFormatter(new SimpleFormatter());
+                 LOGGER.addHandler(consoleHandler);
+                 
+                 // Establecer el nivel de logging
+                 LOGGER.setLevel(Level.ALL);
+             } catch (IOException e) {
+                 e.printStackTrace();
+             }
+         }
+         
+         public static void severe(String message) {
+             LOGGER.severe(formatMessage(message));
+         }
+         
+         public static void warning(String message) {
+             LOGGER.warning(formatMessage(message));
+         }
+         
+         public static void info(String message) {
+             LOGGER.info(formatMessage(message));
+         }
+         
+         public static void config(String message) {
+             LOGGER.config(formatMessage(message));
+         }
+         
+         public static void fine(String message) {
+             LOGGER.fine(formatMessage(message));
+         }
+         
+         private static String formatMessage(String message) {
+             return String.format("[%s] %s",
+                 LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME),
+                 message);
+         }
+     }
+     
+     /**
+      * Clase que representa una tarea
+      */
+     static class Task {
+         private final String name;
+         private final String description;
+         private final LocalDateTime createdAt;
+         
+         public Task(String name, String description) {
+             this.name = name;
+             this.description = description;
+             this.createdAt = LocalDateTime.now();
+         }
+         
+         public String getName() {
+             return name;
+         }
+         
+         public String getDescription() {
+             return description;
+         }
+         
+         public LocalDateTime getCreatedAt() {
+             return createdAt;
+         }
+         
+         @Override
+         public String toString() {
+             return String.format("Tarea: %s - %s (Creada: %s)",
+                 name,
+                 description,
+                 createdAt.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
+         }
+     }
+     
+     /**
+      * Clase para la gestión de tareas
+      */
+     static class TaskManager {
+         private final List<Task> tasks;
+         
+         public TaskManager() {
+             this.tasks = new ArrayList<>();
+         }
+         
+         /**
+          * Mide el tiempo de ejecución de una operación
+          */
+         private void measureExecutionTime(Runnable operation, String operationName) {
+             long startTime = System.nanoTime();
+             try {
+                 operation.run();
+                 long endTime = System.nanoTime();
+                 double executionTime = (endTime - startTime) / 1_000_000.0; // Convertir a millisegundos
+                 CustomLogger.fine(String.format("Tiempo de ejecución %s: %.2fms", 
+                     operationName, executionTime));
+             } catch (Exception e) {
+                 CustomLogger.severe(String.format("Error en %s: %s", 
+                     operationName, e.getMessage()));
+             }
+         }
+         
+         /**
+          * Añade una nueva tarea
+          */
+         public void addTask(String name, String description) {
+             measureExecutionTime(() -> {
+                 // Verificar si ya existe una tarea con el mismo nombre
+                 if (tasks.stream().anyMatch(t -> t.getName().equals(name))) {
+                     CustomLogger.warning(String.format("La tarea '%s' ya existe", name));
+                     return;
+                 }
+                 
+                 Task task = new Task(name, description);
+                 tasks.add(task);
+                 CustomLogger.info(String.format("Tarea '%s' añadida exitosamente", name));
+             }, "addTask");
+         }
+         
+         /**
+          * Elimina una tarea por su nombre
+          */
+         public void removeTask(String name) {
+             measureExecutionTime(() -> {
+                 int initialSize = tasks.size();
+                 tasks.removeIf(task -> task.getName().equals(name));
+                 
+                 if (tasks.size() == initialSize) {
+                     CustomLogger.warning(String.format("No se encontró la tarea '%s'", name));
+                 } else {
+                     CustomLogger.info(String.format("Tarea '%s' eliminada exitosamente", name));
+                 }
+             }, "removeTask");
+         }
+         
+         /**
+          * Lista todas las tareas existentes
+          */
+         public void listTasks() {
+             measureExecutionTime(() -> {
+                 if (tasks.isEmpty()) {
+                     CustomLogger.info("No hay tareas registradas");
+                     return;
+                 }
+                 
+                 CustomLogger.info("Lista de tareas:");
+                 tasks.forEach(task -> CustomLogger.info("- " + task.toString()));
+             }, "listTasks");
+         }
+     }
+     
+     /**
+      * Método principal para demostrar el uso del sistema
+      */
+     public static void main(String[] args) {
+         CustomLogger.info("Iniciando sistema de gestión de tareas");
+         
+         // Demostración de diferentes niveles de logging
+         CustomLogger.severe("Ejemplo de mensaje SEVERE");
+         CustomLogger.warning("Ejemplo de mensaje WARNING");
+         CustomLogger.info("Ejemplo de mensaje INFO");
+         CustomLogger.config("Ejemplo de mensaje CONFIG");
+         CustomLogger.fine("Ejemplo de mensaje FINE");
+         
+         // Crear instancia del gestor de tareas
+         TaskManager taskManager = new TaskManager();
+         
+         // Ejemplos de uso del sistema
+         taskManager.addTask("Estudiar Java", "Aprender sobre logging y POO");
+         taskManager.addTask("Hacer ejercicio", "30 minutos de cardio");
+         taskManager.addTask("Estudiar Java", "Tarea duplicada"); // Intentar añadir duplicada
+         taskManager.listTasks();
+         taskManager.removeTask("Estudiar Java");
+         taskManager.listTasks();
+         taskManager.removeTask("Tarea inexistente");
+         
+         CustomLogger.info("Finalizando sistema de gestión de tareas");
+     }
+ }
\ No newline at end of file
diff --git a/Roadmap/25 - LOGS/javascript/eulogioep.js b/Roadmap/25 - LOGS/javascript/eulogioep.js
new file mode 100644
index 0000000000..196530ff86
--- /dev/null
+++ b/Roadmap/25 - LOGS/javascript/eulogioep.js	
@@ -0,0 +1,206 @@
+/**
+ * TEORÍA SOBRE LOGGING EN JAVASCRIPT
+ * 
+ * JavaScript proporciona varios métodos nativos de logging a través del objeto console:
+ * - console.error(): Para errores críticos
+ * - console.warn(): Para advertencias
+ * - console.info(): Para información general
+ * - console.debug(): Para información de depuración
+ * - console.trace(): Para stack traces
+ * 
+ * Ventajas del logging:
+ * 1. Facilita la depuración
+ * 2. Permite monitorear el estado de la aplicación
+ * 3. Ayuda a diagnosticar problemas en producción
+ * 4. Proporciona información sobre el rendimiento
+ */
+
+// Clase para manejar el logging con niveles de severidad y timestamps
+class Logger {
+    /**
+     * Añade timestamp y formato al mensaje de log
+     * @param {string} level - Nivel de severidad
+     * @param {string} message - Mensaje a registrar
+     * @returns {string} - Mensaje formateado
+     */
+    static formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] [${level}] ${message}`;
+    }
+
+    static error(message) {
+        console.error(this.formatMessage('ERROR', message));
+    }
+
+    static warn(message) {
+        console.warn(this.formatMessage('WARN', message));
+    }
+
+    static info(message) {
+        console.info(this.formatMessage('INFO', message));
+    }
+
+    static debug(message) {
+        console.debug(this.formatMessage('DEBUG', message));
+    }
+
+    static trace(message) {
+        console.trace(this.formatMessage('TRACE', message));
+    }
+}
+
+/**
+ * Clase que representa una tarea
+ */
+class Task {
+    /**
+     * @param {string} name - Nombre de la tarea
+     * @param {string} description - Descripción de la tarea
+     */
+    constructor(name, description) {
+        this.name = name;
+        this.description = description;
+        this.createdAt = new Date();
+        this.id = crypto.randomUUID(); // Generamos un ID único para cada tarea
+    }
+}
+
+/**
+ * Clase para la gestión de tareas
+ */
+class TaskManager {
+    constructor() {
+        this.tasks = new Map(); // Usamos Map para almacenar las tareas por su nombre
+    }
+
+    /**
+     * Mide el tiempo de ejecución de una función
+     * @param {Function} fn - Función a ejecutar
+     * @param {string} operationName - Nombre de la operación
+     * @returns {*} - Resultado de la función
+     */
+    async measureExecutionTime(fn, operationName) {
+        const startTime = performance.now();
+        try {
+            const result = await fn();
+            const endTime = performance.now();
+            Logger.debug(`Tiempo de ejecución ${operationName}: ${(endTime - startTime).toFixed(2)}ms`);
+            return result;
+        } catch (error) {
+            Logger.error(`Error en ${operationName}: ${error.message}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Añade una nueva tarea
+     * @param {string} name - Nombre de la tarea
+     * @param {string} description - Descripción de la tarea
+     */
+    async addTask(name, description) {
+        await this.measureExecutionTime(async () => {
+            if (this.tasks.has(name)) {
+                Logger.warn(`La tarea "${name}" ya existe`);
+                return;
+            }
+
+            const task = new Task(name, description);
+            this.tasks.set(name, task);
+            Logger.info(`Tarea "${name}" añadida exitosamente`);
+        }, 'addTask');
+    }
+
+    /**
+     * Elimina una tarea por su nombre
+     * @param {string} name - Nombre de la tarea a eliminar
+     */
+    async removeTask(name) {
+        await this.measureExecutionTime(async () => {
+            if (!this.tasks.has(name)) {
+                Logger.warn(`No se encontró la tarea "${name}"`);
+                return;
+            }
+
+            this.tasks.delete(name);
+            Logger.info(`Tarea "${name}" eliminada exitosamente`);
+        }, 'removeTask');
+    }
+
+    /**
+     * Lista todas las tareas existentes
+     */
+    async listTasks() {
+        await this.measureExecutionTime(async () => {
+            if (this.tasks.size === 0) {
+                Logger.info("No hay tareas registradas");
+                return;
+            }
+
+            Logger.info("Lista de tareas:");
+            for (const task of this.tasks.values()) {
+                Logger.info(
+                    `- ${task.name}: ${task.description} ` +
+                    `(Creada: ${task.createdAt.toISOString()}) ` +
+                    `[ID: ${task.id}]`
+                );
+            }
+        }, 'listTasks');
+    }
+}
+
+/**
+ * Función principal para demostrar el uso del sistema
+ */
+async function main() {
+    try {
+        Logger.info("Iniciando sistema de gestión de tareas");
+
+        // Demostración de diferentes niveles de logging
+        Logger.error("Ejemplo de mensaje de error");
+        Logger.warn("Ejemplo de mensaje de advertencia");
+        Logger.info("Ejemplo de mensaje informativo");
+        Logger.debug("Ejemplo de mensaje de depuración");
+        Logger.trace("Ejemplo de mensaje de trace");
+
+        // Crear instancia del gestor de tareas
+        const taskManager = new TaskManager();
+
+        // Ejemplos de uso del sistema
+        await taskManager.addTask(
+            "Aprender JavaScript", 
+            "Estudiar conceptos avanzados de JS"
+        );
+        
+        await taskManager.addTask(
+            "Hacer ejercicio", 
+            "30 minutos de cardio"
+        );
+
+        // Intentar añadir una tarea duplicada
+        await taskManager.addTask(
+            "Aprender JavaScript", 
+            "Tarea duplicada"
+        );
+
+        // Listar tareas
+        await taskManager.listTasks();
+
+        // Eliminar una tarea
+        await taskManager.removeTask("Aprender JavaScript");
+
+        // Listar tareas actualizadas
+        await taskManager.listTasks();
+
+        // Intentar eliminar una tarea que no existe
+        await taskManager.removeTask("Tarea inexistente");
+
+        Logger.info("Finalizando sistema de gestión de tareas");
+    } catch (error) {
+        Logger.error(`Error en la ejecución principal: ${error.message}`);
+    }
+}
+
+// Ejecutar el programa
+main().catch(error => {
+    Logger.error(`Error crítico: ${error.message}`);
+});
\ No newline at end of file
diff --git a/Roadmap/25 - LOGS/php/eulogioep.php b/Roadmap/25 - LOGS/php/eulogioep.php
new file mode 100644
index 0000000000..37198c2193
--- /dev/null
+++ b/Roadmap/25 - LOGS/php/eulogioep.php	
@@ -0,0 +1,217 @@
+<?php
+/**
+ * TEORÍA SOBRE LOGGING EN PHP
+ * 
+ * PHP proporciona varias formas de implementar logging:
+ * 1. error_log() - Función nativa de PHP para logging
+ * 2. syslog() - Para logging en el sistema operativo
+ * 3. file_put_contents() - Para escribir logs en archivos
+ * 4. Librerías como Monolog - Soluciones más completas
+ * 
+ * Niveles de severidad estándar (PSR-3):
+ * - EMERGENCY: Sistema inutilizable
+ * - ALERT: Acción inmediata requerida
+ * - CRITICAL: Condiciones críticas
+ * - ERROR: Condiciones de error
+ * - WARNING: Condiciones de advertencia
+ * - NOTICE: Eventos normales pero significativos
+ * - INFO: Mensajes informativos
+ * - DEBUG: Información detallada de depuración
+ */
+
+/**
+ * Clase Logger personalizada para manejar diferentes niveles de logging
+ */
+class Logger {
+    private string $logFile;
+    
+    public function __construct(string $logFile = 'app.log') {
+        $this->logFile = $logFile;
+    }
+    
+    /**
+     * Método privado para escribir el log
+     */
+    private function writeLog(string $level, string $message): void {
+        $timestamp = date('Y-m-d H:i:s');
+        $logMessage = "[$timestamp] [$level] $message" . PHP_EOL;
+        
+        // Escribir en archivo
+        file_put_contents($this->logFile, $logMessage, FILE_APPEND);
+        
+        // También mostrar en consola para este ejemplo
+        echo $logMessage;
+    }
+    
+    public function emergency(string $message): void {
+        $this->writeLog('EMERGENCY', $message);
+    }
+    
+    public function alert(string $message): void {
+        $this->writeLog('ALERT', $message);
+    }
+    
+    public function critical(string $message): void {
+        $this->writeLog('CRITICAL', $message);
+    }
+    
+    public function error(string $message): void {
+        $this->writeLog('ERROR', $message);
+    }
+    
+    public function warning(string $message): void {
+        $this->writeLog('WARNING', $message);
+    }
+    
+    public function notice(string $message): void {
+        $this->writeLog('NOTICE', $message);
+    }
+    
+    public function info(string $message): void {
+        $this->writeLog('INFO', $message);
+    }
+    
+    public function debug(string $message): void {
+        $this->writeLog('DEBUG', $message);
+    }
+}
+
+/**
+ * Clase que representa una Tarea
+ */
+class Task {
+    public function __construct(
+        public string $name,
+        public string $description,
+        public DateTime $createdAt
+    ) {}
+}
+
+/**
+ * Clase para la gestión de tareas con logging integrado
+ */
+class TaskManager {
+    private array $tasks = [];
+    private Logger $logger;
+    
+    public function __construct(Logger $logger) {
+        $this->logger = $logger;
+    }
+    
+    /**
+     * Añade una nueva tarea al sistema
+     */
+    public function addTask(string $name, string $description): void {
+        $startTime = microtime(true);
+        
+        try {
+            // Verificar si ya existe una tarea con el mismo nombre
+            foreach ($this->tasks as $task) {
+                if ($task->name === $name) {
+                    $this->logger->error("La tarea '$name' ya existe");
+                    return;
+                }
+            }
+            
+            $task = new Task($name, $description, new DateTime());
+            $this->tasks[] = $task;
+            
+            $this->logger->info("Tarea '$name' añadida exitosamente");
+            
+            $endTime = microtime(true);
+            $executionTime = ($endTime - $startTime) * 1000; // Convertir a millisegundos
+            $this->logger->debug("Tiempo de ejecución addTask: {$executionTime}ms");
+            
+        } catch (Exception $e) {
+            $this->logger->error("Error al añadir tarea: " . $e->getMessage());
+        }
+    }
+    
+    /**
+     * Elimina una tarea por su nombre
+     */
+    public function removeTask(string $name): void {
+        $startTime = microtime(true);
+        
+        try {
+            $initialCount = count($this->tasks);
+            $this->tasks = array_filter(
+                $this->tasks,
+                fn($task) => $task->name !== $name
+            );
+            
+            if (count($this->tasks) === $initialCount) {
+                $this->logger->warning("No se encontró la tarea '$name'");
+            } else {
+                $this->logger->info("Tarea '$name' eliminada exitosamente");
+            }
+            
+            $endTime = microtime(true);
+            $executionTime = ($endTime - $startTime) * 1000;
+            $this->logger->debug("Tiempo de ejecución removeTask: {$executionTime}ms");
+            
+        } catch (Exception $e) {
+            $this->logger->error("Error al eliminar tarea: " . $e->getMessage());
+        }
+    }
+    
+    /**
+     * Lista todas las tareas existentes
+     */
+    public function listTasks(): void {
+        $startTime = microtime(true);
+        
+        try {
+            if (empty($this->tasks)) {
+                $this->logger->info("No hay tareas registradas");
+                return;
+            }
+            
+            $this->logger->info("Lista de tareas:");
+            foreach ($this->tasks as $task) {
+                $createdAt = $task->createdAt->format('Y-m-d H:i:s');
+                $this->logger->info("- {$task->name}: {$task->description} (Creada: $createdAt)");
+            }
+            
+            $endTime = microtime(true);
+            $executionTime = ($endTime - $startTime) * 1000;
+            $this->logger->debug("Tiempo de ejecución listTasks: {$executionTime}ms");
+            
+        } catch (Exception $e) {
+            $this->logger->error("Error al listar tareas: " . $e->getMessage());
+        }
+    }
+}
+
+// Ejemplo de uso del sistema
+function main() {
+    // Crear instancia del logger
+    $logger = new Logger('tareas.log');
+    $logger->info("Iniciando sistema de gestión de tareas");
+    
+    // Crear instancia del gestor de tareas
+    $taskManager = new TaskManager($logger);
+    
+    // Demostrar diferentes niveles de logging
+    $logger->emergency("Ejemplo de mensaje emergency");
+    $logger->alert("Ejemplo de mensaje alert");
+    $logger->critical("Ejemplo de mensaje critical");
+    $logger->error("Ejemplo de mensaje error");
+    $logger->warning("Ejemplo de mensaje warning");
+    $logger->notice("Ejemplo de mensaje notice");
+    $logger->info("Ejemplo de mensaje info");
+    $logger->debug("Ejemplo de mensaje debug");
+    
+    // Ejemplos de uso del gestor de tareas
+    $taskManager->addTask("Estudiar PHP", "Aprender sobre logging y POO");
+    $taskManager->addTask("Hacer ejercicio", "30 minutos de cardio");
+    $taskManager->listTasks();
+    $taskManager->removeTask("Estudiar PHP");
+    $taskManager->listTasks();
+    $taskManager->removeTask("Tarea inexistente");
+    
+    $logger->info("Finalizando sistema de gestión de tareas");
+}
+
+// Ejecutar el programa
+main();
\ No newline at end of file
diff --git a/Roadmap/25 - LOGS/typescript/eulogioep.ts b/Roadmap/25 - LOGS/typescript/eulogioep.ts
new file mode 100644
index 0000000000..e7d2f351cf
--- /dev/null
+++ b/Roadmap/25 - LOGS/typescript/eulogioep.ts	
@@ -0,0 +1,158 @@
+/**
+ * TEORÍA SOBRE LOGGING EN TYPESCRIPT
+ * 
+ * El logging es una práctica fundamental en el desarrollo de software que permite:
+ * - Registrar eventos y estados durante la ejecución del programa
+ * - Facilitar la depuración y el diagnóstico de problemas
+ * - Monitorear el rendimiento y comportamiento de la aplicación
+ * 
+ * Niveles de severidad comunes:
+ * - ERROR: Errores críticos que impiden el funcionamiento correcto
+ * - WARN: Advertencias sobre situaciones potencialmente problemáticas
+ * - INFO: Información general sobre el flujo del programa
+ * - DEBUG: Información detallada útil para depuración
+ * - TRACE: Información muy detallada sobre el flujo de ejecución
+ */
+
+// Importamos la biblioteca de logging (en este caso usaremos console por simplicidad)
+class Logger {
+    static error(message: string) {
+        console.error(`[ERROR] ${new Date().toISOString()} - ${message}`);
+    }
+
+    static warn(message: string) {
+        console.warn(`[WARN] ${new Date().toISOString()} - ${message}`);
+    }
+
+    static info(message: string) {
+        console.info(`[INFO] ${new Date().toISOString()} - ${message}`);
+    }
+
+    static debug(message: string) {
+        console.debug(`[DEBUG] ${new Date().toISOString()} - ${message}`);
+    }
+
+    static trace(message: string) {
+        console.trace(`[TRACE] ${new Date().toISOString()} - ${message}`);
+    }
+}
+
+// Ejemplo básico de uso de diferentes niveles de logging
+function demonstrateLogging() {
+    Logger.error("Error crítico en la conexión a la base de datos");
+    Logger.warn("El espacio en disco está por debajo del 20%");
+    Logger.info("Aplicación iniciada correctamente");
+    Logger.debug("Valor de la variable x: 42");
+    Logger.trace("Entrando en la función calculateTotal()");
+}
+
+// Definición de la interfaz para una tarea
+interface Task {
+    name: string;
+    description: string;
+    createdAt: Date;
+}
+
+// Clase para la gestión de tareas
+class TaskManager {
+    private tasks: Task[] = [];
+
+    /**
+     * Añade una nueva tarea al sistema
+     * @param name Nombre de la tarea
+     * @param description Descripción de la tarea
+     */
+    addTask(name: string, description: string): void {
+        const startTime = performance.now();
+        
+        try {
+            // Verificar si ya existe una tarea con el mismo nombre
+            if (this.tasks.some(task => task.name === name)) {
+                Logger.error(`Tarea "${name}" ya existe`);
+                return;
+            }
+
+            const newTask: Task = {
+                name,
+                description,
+                createdAt: new Date()
+            };
+
+            this.tasks.push(newTask);
+            Logger.info(`Tarea "${name}" añadida exitosamente`);
+            
+            const endTime = performance.now();
+            Logger.debug(`Tiempo de ejecución addTask: ${endTime - startTime}ms`);
+        } catch (error) {
+            Logger.error(`Error al añadir tarea: ${error}`);
+        }
+    }
+
+    /**
+     * Elimina una tarea por su nombre
+     * @param name Nombre de la tarea a eliminar
+     */
+    removeTask(name: string): void {
+        const startTime = performance.now();
+        
+        try {
+            const initialLength = this.tasks.length;
+            this.tasks = this.tasks.filter(task => task.name !== name);
+
+            if (this.tasks.length === initialLength) {
+                Logger.warn(`No se encontró la tarea "${name}"`);
+            } else {
+                Logger.info(`Tarea "${name}" eliminada exitosamente`);
+            }
+
+            const endTime = performance.now();
+            Logger.debug(`Tiempo de ejecución removeTask: ${endTime - startTime}ms`);
+        } catch (error) {
+            Logger.error(`Error al eliminar tarea: ${error}`);
+        }
+    }
+
+    /**
+     * Lista todas las tareas existentes
+     */
+    listTasks(): void {
+        const startTime = performance.now();
+        
+        try {
+            if (this.tasks.length === 0) {
+                Logger.info("No hay tareas registradas");
+                return;
+            }
+
+            Logger.info("Lista de tareas:");
+            this.tasks.forEach(task => {
+                Logger.info(`- ${task.name}: ${task.description} (Creada: ${task.createdAt})`);
+            });
+
+            const endTime = performance.now();
+            Logger.debug(`Tiempo de ejecución listTasks: ${endTime - startTime}ms`);
+        } catch (error) {
+            Logger.error(`Error al listar tareas: ${error}`);
+        }
+    }
+}
+
+// Ejemplo de uso
+function main() {
+    Logger.info("Iniciando sistema de gestión de tareas");
+
+    const taskManager = new TaskManager();
+
+    // Ejemplo de uso del sistema
+    taskManager.addTask("Estudiar TypeScript", "Aprender sobre tipos y interfaces");
+    taskManager.addTask("Hacer ejercicio", "30 minutos de cardio");
+    taskManager.listTasks();
+    taskManager.removeTask("Estudiar TypeScript");
+    taskManager.listTasks();
+    taskManager.removeTask("Tarea inexistente");
+
+    Logger.info("Finalizando sistema de gestión de tareas");
+}
+
+// Ejecutar el programa
+main();
\ No newline at end of file