DEV Community: Rubén Dario Hernández González

UI Optimista: El Secreto de las Apps que se Sienten Instantáneas

Rubén Dario Hernández González — Mon, 06 Oct 2025 20:46:09 +0000

¿Alguna vez has usado una app donde tocas un botón y tienes que esperar a que un círculo giratorio termine para ver tu cambio? Ese pequeño momento de espera, aunque breve, rompe la fluidez de la experiencia. Le grita al usuario: "¡Espera, estoy hablando con el servidor!".

Y si la conexión es lenta... la espera se convierte en frustración.

Hoy vamos a hablar de una técnica poderosa que elimina esa espera y transforma la percepción de velocidad de tu aplicación: la UI Optimista.

El flujo optimista: actualizas la UI inmediatamente, llamas a la API en segundo plano,
y solo reviertes si hay un error.

El Problema: El Flujo Tradicional (El que siempre nos enseñan)

El enfoque tradicional asume que la operación podría fallar. Por lo tanto, no hace nada hasta tener la confirmación del servidor.

Veamos un ejemplo universal: marcar una tarea como completada en una To-Do List.

Flujo Tradicional:

Usuario: Toca el checkbox de una tarea.
App: Muestra un spinner o deshabilita el checkbox.
App -> Servidor: Envía la petición UPDATE /tasks/123 { completed: true }.
App: Espera...
Servidor -> App: Responde 200 OK.
App: Oculta el spinner y finalmente marca el checkbox como completado.

Este flujo es seguro, pero es lento. La UI siempre va un paso por detrás del estado real en el servidor.

La Solución: El Flujo Optimista (La Magia de la Inmediatez)

La UI Optimista cambia las reglas del juego. Asume que la operación tendrá éxito y actualiza la interfaz de usuario inmediatamente.

Flujo Optimista:

Usuario: Toca el checkbox de una tarea.
App: ¡Marca el checkbox al instante! La tarea aparece como completada. La interfaz se siente increíblemente rápida.
App -> Servidor (en segundo plano): Envía la petición UPDATE /tasks/123 { completed: true }.
Manejo de la Respuesta:
- Caso Feliz (99% de las veces): El servidor responde 200 OK. La app no hace nada más. La UI ya estaba correcta.
- Caso Triste (Error de red, etc.): El servidor responde con un error. La app revierte el cambio (desmarca el checkbox) y muestra un mensaje sutil como "No se pudo completar la tarea. Inténtalo de nuevo."

El usuario solo nota un problema si algo sale mal. El resto del tiempo, la experiencia es fluida e instantánea.

¿Cómo se Implementa? Un Ejemplo Sencillo con Flutter y Provider

Este patrón brilla cuando tienes una buena arquitectura. Si tu lógica de estado está en un Provider (o cualquier otro gestor de estado como BLoC o Riverpod), la implementación es sorprendentemente sencilla.

Imagina que tenemos un TodosProvider. El método para marcar una tarea como completada cambiaría de esto...

El Código Tradicional:

// En tu TodosProvider
Future<void> toggleTodoStatus(String todoId) async {
  _state = ViewState.loading;
  notifyListeners();

  try {
    // 1. Llama a la API
    await _todosRepository.updateTodoStatus(todoId);

    // 2. Si todo va bien, actualiza el estado local
    final todo = _todos.firstWhere((t) => t.id == todoId);
    todo.isCompleted = !todo.isCompleted;
    _state = ViewState.loaded;
  } catch (e) {
    _state = ViewState.error;
    _errorMessage = e.toString();
  }

  notifyListeners();
}

...a esto:

El Código Optimista:

// En tu TodosProvider
Future<void> toggleTodoStatus(String todoId) async {
  // 1. Encuentra la tarea y guarda su estado original
  final todoIndex = _todos.indexWhere((t) => t.id == todoId);
  if (todoIndex == -1) return;
  final todo = _todos[todoIndex];
  final originalStatus = todo.isCompleted;

  // 2. ¡Actualiza la UI INMEDIATAMENTE!
  _todos[todoIndex].isCompleted = !originalStatus;
  notifyListeners();

  try {
    // 3. Llama a la API en segundo plano
    await _todosRepository.updateTodoStatus(todoId);
  } catch (e) {
    // 4. ¡Oh no! Algo falló. Revierte el cambio y notifica al usuario.
    _todos[todoIndex].isCompleted = originalStatus; // Vuelve al estado original
    _errorMessage = "No se pudo actualizar la tarea. Revisa tu conexión.";
    notifyListeners(); // Notifica a la UI para que se revierta y muestre el error
  }
}

Los Tres Escenarios que Debes Anticipar

La UI Optimista funciona genial... hasta que no. Aquí están los casos que debes manejar:

1. El Usuario Toca Dos Veces (muy rápido)

Si alguien hace doble-click accidental, podrías tener dos peticiones en vuelo con estados contradictorios.

Solución simple: Deshabilita la acción mientras hay una petición pendiente usando un flag isUpdating.

2. Dos Dispositivos, Mismo Usuario

Tu usuario marca la tarea como completada en su teléfono. Dos segundos después, la desmarca en su laptop. ¿Cuál gana?

Solución: Usa timestamps o versiones. El servidor decide quién llegó último. Tu app debe escuchar cambios en tiempo real (WebSockets, Firebase) y actualizar la UI cuando el servidor diga que algo cambió.

3. Se Cerró la App Antes de que Llegara la Respuesta

La UI ya cambió, pero la petición nunca llegó al servidor. Cuando el usuario vuelva a abrir la app, verá la tarea como "completada" localmente, pero el servidor dirá lo contrario.

Solución: Al iniciar la app, siempre haz un refresh desde el servidor. La verdad vive en el backend, no en tu estado local.

¿Por Qué y Cuándo Deberías Usar UI Optimista?

¿Por Qué? Porque crea una experiencia de usuario superior. Las apps se sienten más rápidas, más responsivas y menos "conectadas a internet". Aumenta la satisfacción del usuario y reduce la frustración causada por la latencia de la red.
¿Cuándo? Es ideal para acciones de baja a media criticidad que tienen una alta probabilidad de éxito.
- Perfecto para: Dar "Me Gusta", marcar una notificación como leída, archivar un correo, añadir un producto al carrito, completar una tarea.
- No tan bueno para: Transacciones financieras críticas como "Realizar Pago" o acciones de eliminación irreversibles donde el usuario necesita la confirmación del servidor antes de continuar.

Indicadores Visuales: La Diferencia Entre Bueno y Excelente

La UI Optimista no significa cero feedback. Significa feedback inteligente.

Aunque actualices la interfaz inmediatamente, un indicador visual sutil puede mejorar la experiencia sin sacrificar la sensación de velocidad.

Opción 1: Opacidad Reducida

Mientras la operación se sincroniza en segundo plano, reduce la opacidad del elemento a 0.6. Cuando el servidor confirma, vuelve a 1.0. Es tan sutil que el usuario apenas lo nota conscientemente, pero su cerebro registra que "algo está pasando".

Opción 2: Ícono de Sincronización Micro

Un pequeño ícono de sincronización (16x16px) en la esquina del elemento. Aparece por 1-2 segundos y desaparece cuando la operación se completa. No es intrusivo como un spinner de pantalla completa, pero comunica el estado.

Opción 3: Animación de Confirmación

Cuando el servidor responde exitosamente, un destello verde suave o una animación de "check" rápida. Esto cierra el loop psicológico del usuario: "Mi acción fue recibida y procesada".

Lo que NO debes hacer

No uses spinners de pantalla completa, no bloquees la UI, y no hagas que el usuario espere para continuar con otras acciones. El punto es que la app siga siendo completamente usable mientras sincronizas en segundo plano.

Conclusión

La UI Optimista es más que una simple técnica; es un cambio de mentalidad enfocado en el usuario. Al diseñar nuestras aplicaciones para que sean fluidas por defecto y manejen los errores como la excepción y no la norma, construimos productos que no solo funcionan, sino que se sienten geniales al usar.

La próxima vez que estés a punto de añadir un CircularProgressIndicator a un botón, pregúntate: ¿Puedo ser optimista?

Conecta Conmigo

Si te gustó este artículo, sígueme para más contenido sobre desarrollo móvil, arquitectura y UX.

💻 GitHub

¿Tienes experiencias con UI Optimista? Comparte en los comentarios.

UI Optimista: El Secreto de las Apps que se Sienten Instantáneas

Rubén Dario Hernández González — Mon, 06 Oct 2025 20:46:09 +0000

Y si la conexión es lenta... la espera se convierte en frustración.

Hoy vamos a hablar de una técnica poderosa que elimina esa espera y transforma la percepción de velocidad de tu aplicación: la UI Optimista.

El flujo optimista: actualizas la UI inmediatamente, llamas a la API en segundo plano,
y solo reviertes si hay un error.

El Problema: El Flujo Tradicional (El que siempre nos enseñan)

El enfoque tradicional asume que la operación podría fallar. Por lo tanto, no hace nada hasta tener la confirmación del servidor.

Veamos un ejemplo universal: marcar una tarea como completada en una To-Do List.

Flujo Tradicional:

Usuario: Toca el checkbox de una tarea.
App: Muestra un spinner o deshabilita el checkbox.
App -> Servidor: Envía la petición UPDATE /tasks/123 { completed: true }.
App: Espera...
Servidor -> App: Responde 200 OK.
App: Oculta el spinner y finalmente marca el checkbox como completado.

Este flujo es seguro, pero es lento. La UI siempre va un paso por detrás del estado real en el servidor.

La Solución: El Flujo Optimista (La Magia de la Inmediatez)

La UI Optimista cambia las reglas del juego. Asume que la operación tendrá éxito y actualiza la interfaz de usuario inmediatamente.

Flujo Optimista:

Usuario: Toca el checkbox de una tarea.
App: ¡Marca el checkbox al instante! La tarea aparece como completada. La interfaz se siente increíblemente rápida.
App -> Servidor (en segundo plano): Envía la petición UPDATE /tasks/123 { completed: true }.
Manejo de la Respuesta:
- Caso Feliz (99% de las veces): El servidor responde 200 OK. La app no hace nada más. La UI ya estaba correcta.
- Caso Triste (Error de red, etc.): El servidor responde con un error. La app revierte el cambio (desmarca el checkbox) y muestra un mensaje sutil como "No se pudo completar la tarea. Inténtalo de nuevo."

El usuario solo nota un problema si algo sale mal. El resto del tiempo, la experiencia es fluida e instantánea.

¿Cómo se Implementa? Un Ejemplo Sencillo con Flutter y Provider

Imagina que tenemos un TodosProvider. El método para marcar una tarea como completada cambiaría de esto...

El Código Tradicional:

// En tu TodosProvider
Future<void> toggleTodoStatus(String todoId) async {
  _state = ViewState.loading;
  notifyListeners();

  try {
    // 1. Llama a la API
    await _todosRepository.updateTodoStatus(todoId);

    // 2. Si todo va bien, actualiza el estado local
    final todo = _todos.firstWhere((t) => t.id == todoId);
    todo.isCompleted = !todo.isCompleted;
    _state = ViewState.loaded;
  } catch (e) {
    _state = ViewState.error;
    _errorMessage = e.toString();
  }

  notifyListeners();
}

...a esto:

El Código Optimista:

// En tu TodosProvider
Future<void> toggleTodoStatus(String todoId) async {
  // 1. Encuentra la tarea y guarda su estado original
  final todoIndex = _todos.indexWhere((t) => t.id == todoId);
  if (todoIndex == -1) return;
  final todo = _todos[todoIndex];
  final originalStatus = todo.isCompleted;

  // 2. ¡Actualiza la UI INMEDIATAMENTE!
  _todos[todoIndex].isCompleted = !originalStatus;
  notifyListeners();

  try {
    // 3. Llama a la API en segundo plano
    await _todosRepository.updateTodoStatus(todoId);
  } catch (e) {
    // 4. ¡Oh no! Algo falló. Revierte el cambio y notifica al usuario.
    _todos[todoIndex].isCompleted = originalStatus; // Vuelve al estado original
    _errorMessage = "No se pudo actualizar la tarea. Revisa tu conexión.";
    notifyListeners(); // Notifica a la UI para que se revierta y muestre el error
  }
}

Los Tres Escenarios que Debes Anticipar

La UI Optimista funciona genial... hasta que no. Aquí están los casos que debes manejar:

1. El Usuario Toca Dos Veces (muy rápido)

Si alguien hace doble-click accidental, podrías tener dos peticiones en vuelo con estados contradictorios.

Solución simple: Deshabilita la acción mientras hay una petición pendiente usando un flag isUpdating.

2. Dos Dispositivos, Mismo Usuario

Tu usuario marca la tarea como completada en su teléfono. Dos segundos después, la desmarca en su laptop. ¿Cuál gana?

3. Se Cerró la App Antes de que Llegara la Respuesta

La UI ya cambió, pero la petición nunca llegó al servidor. Cuando el usuario vuelva a abrir la app, verá la tarea como "completada" localmente, pero el servidor dirá lo contrario.

Solución: Al iniciar la app, siempre haz un refresh desde el servidor. La verdad vive en el backend, no en tu estado local.

¿Por Qué y Cuándo Deberías Usar UI Optimista?

¿Por Qué? Porque crea una experiencia de usuario superior. Las apps se sienten más rápidas, más responsivas y menos "conectadas a internet". Aumenta la satisfacción del usuario y reduce la frustración causada por la latencia de la red.
¿Cuándo? Es ideal para acciones de baja a media criticidad que tienen una alta probabilidad de éxito.
- Perfecto para: Dar "Me Gusta", marcar una notificación como leída, archivar un correo, añadir un producto al carrito, completar una tarea.
- No tan bueno para: Transacciones financieras críticas como "Realizar Pago" o acciones de eliminación irreversibles donde el usuario necesita la confirmación del servidor antes de continuar.

Indicadores Visuales: La Diferencia Entre Bueno y Excelente

La UI Optimista no significa cero feedback. Significa feedback inteligente.

Aunque actualices la interfaz inmediatamente, un indicador visual sutil puede mejorar la experiencia sin sacrificar la sensación de velocidad.

Opción 1: Opacidad Reducida

Opción 2: Ícono de Sincronización Micro

Opción 3: Animación de Confirmación

Cuando el servidor responde exitosamente, un destello verde suave o una animación de "check" rápida. Esto cierra el loop psicológico del usuario: "Mi acción fue recibida y procesada".

Lo que NO debes hacer

Conclusión

La próxima vez que estés a punto de añadir un CircularProgressIndicator a un botón, pregúntate: ¿Puedo ser optimista?

Conecta Conmigo

Si te gustó este artículo, sígueme para más contenido sobre desarrollo móvil, arquitectura y UX.

💻 GitHub

¿Tienes experiencias con UI Optimista? Comparte en los comentarios.

[Boost]

Rubén Dario Hernández González — Mon, 06 Oct 2025 20:19:24 +0000

Julio César Pérez Ortiz

Oct 6 '25

Object Pooling en Flutter: Cuando Reutilizar es Mejor que Recrear

#flutter #performance #dart #objectpooling

Comments

4 min read

Sistemas Operativos e Inteligencia Artificial en 2025: Sinergias y Revolución Tecnológica

Rubén Dario Hernández González — Mon, 17 Feb 2025 17:14:51 +0000

Introducción

La integración de la inteligencia artificial (IA) en los sistemas operativos (SO) ha alcanzado un punto de madurez en 2025, redefiniendo cómo interactuamos con la tecnología. Desde la optimización de recursos hasta la personalización extrema, los SO modernos se han convertido en plataformas inteligentes que anticipan necesidades, resuelven problemas y mejoran la productividad. A continuación, exploramos los avances clave y su impacto en la industria y la vida cotidiana.

1. Hardware Especializado para IA en Sistemas Operativos

Los sistemas operativos de 2025 dependen de hardware avanzado diseñado para ejecutar modelos de IA de forma eficiente. Los Neural Processing Units (NPU) se han integrado en procesadores como los Intel Ultra, AMD Ryzen PRO y Apple M-series, permitiendo operaciones de IA localizadas con menor consumo energético y mayor velocidad. Estos chips aceleran tareas como el procesamiento de lenguaje natural, el reconocimiento de imágenes y la generación de contenido en tiempo real.

Por ejemplo, Windows 11 ha incorporado funciones como Copilot+, que utiliza NPUs para ofrecer asistentes de escritura, resúmenes automáticos y optimización de videollamadas con desenfoque de fondo basado en IA. Apple, por su parte, ha lanzado Apple Intelligence, un conjunto de herramientas integradas en macOS que generan avatares, corrigen textos y gestionan tareas mediante modelos locales entrenados con Llama 3 de Meta.

2. Personalización Adaptativa y Experiencia de Usuario

La IA ha llevado la personalización a niveles sin precedentes. Los sistemas operativos analizan patrones de comportamiento, preferencias e incluso estados emocionales (mediante cámaras y micrófonos) para adaptar interfaces y funcionalidades. Por ejemplo:

Hiperpersonalización de aplicaciones: Los SO priorizan herramientas usadas frecuentemente y ajustan configuraciones automáticamente.
Asistentes predictivos: Agentes de IA como AI Now de Lenovo ejecutan tareas en segundo plano, como organizar correos electrónicos o gestionar calendarios, sin necesidad de conexión a internet.

Esta adaptabilidad no solo mejora la productividad, sino que también reduce la curva de aprendizaje para usuarios menos técnicos.

3. Seguridad y Privacidad Mejoradas por IA

La ciberseguridad ha evolucionado gracias a algoritmos de IA integrados en los SO. Estos sistemas detectan amenazas en tiempo real, como malware o phishing, mediante análisis predictivo y aprendizaje automático. Por ejemplo:

Autenticación biométrica avanzada: Reconocimiento facial con ajustes de iluminación y postura, incluso en condiciones adversas.
Protección de datos locales: Al procesar información sensible en el dispositivo (en lugar de la nube), se minimizan riesgos de filtraciones.

Además, marcos regulatorios como la Ley de IA de la UE exigen transparencia en el uso de datos, lo que ha impulsado a los desarrolladores a implementar sistemas de auditoría integrados en los SO.

4. Integración de IA Multimodal y Agentes Autónomos

Los sistemas operativos modernos soportan IA multimodal, combinando texto, voz, imágenes y sensores para ofrecer respuestas contextuales. Un ejemplo es la capacidad de los SO para transcribir reuniones, generar actas y destacar puntos clave automáticamente.

Además, los agentes autónomos —como los propuestos por Moody’s— permiten a los SO planificar y ejecutar tareas complejas, como optimizar la cadena de suministro de una empresa o gestionar actualizaciones de software sin intervención humana.

5. Sostenibilidad y Eficiencia Energética

La IA en los SO contribuye a reducir el impacto ambiental. Algoritmos de optimización gestionan el consumo de energía, apagando componentes no esenciales o priorizando procesos en segundo plano durante horas de baja demanda. Empresas como HP y Lenovo han lanzado dispositivos con NPUs de bajo consumo, diseñados para operaciones de IA sin sobrecargar la batería

Fuentes Utilizadas

Inteligencia Artificial en 2025: Tendencias y Perspectivas
IA en 2025: mayores capacidades y nuevos casos de uso
Integración de sistemas de inteligencia artificial
2025: el año del PC con inteligencia artificial
Tendencias de inteligencia artificial 2025
Avances Tecnológicos: IA Generativa y Robótica

Mi proyecto fue guiado por @jmaciasm. ¡Gracias por la mentoría!

Simulador de Estacionamiento en Go con Fyne: Aprendizajes y Consejos

Rubén Dario Hernández González — Mon, 09 Dec 2024 01:19:22 +0000

Introducción

Desarrollar un Simulador de Estacionamiento fue una experiencia educativa que nos permitió explorar y aplicar conceptos fundamentales de programación concurrente utilizando el lenguaje Go, así como diseñar una interfaz gráfica intuitiva con la biblioteca Fyne. Este proyecto, creado como parte de una actividad escolar, no solo reforzó nuestros conocimientos técnicos, sino que también nos enseñó la importancia de una buena planificación y la colaboración efectiva en el desarrollo de software.

En este reporte, compartiremos los principales aprendizajes obtenidos durante la elaboración del simulador y ofreceremos consejos prácticos para aquellos interesados en utilizar Fyne para sus propios proyectos.

Aprendizajes Clave

1.- Programación Concurrente con Go
Uno de los aspectos más destacados del proyecto fue la utilización de la concurrencia en Go. La capacidad de manejar múltiples procesos simultáneamente es esencial para simular la llegada y salida de vehículos en tiempo real. Aprendimos a:

Goroutines: Permiten ejecutar funciones de manera concurrente. Por ejemplo, cada vehículo que intenta entrar al estacionamiento se maneja en una goroutine separada, simulando múltiples vehículos actuando al mismo tiempo.

go p.TryToEnter(vehicle)

Canales: Facilitan la comunicación entre goroutines, permitiendo enviar y recibir mensajes de manera segura.

p.gate = make(chan struct{}, 1)

Mutexes: Garantizan que solo una goroutine acceda a ciertos recursos compartidos a la vez, evitando condiciones de carrera.

var mutex sync.Mutex
mutex.Lock()
// acceso a recurso compartido
mutex.Unlock()

2.- Diseño de Interfaces Gráficas con Fyne
La biblioteca Fyne fue elegida para desarrollar la interfaz gráfica del simulador debido a su facilidad de uso y capacidad para crear aplicaciones visualmente atractivas. Aprendimos a:

Crear Ventanas y Contenedores:

myApp := app.New()
window := myApp.NewWindow("Parking Lot Simulator")
window.Resize(fyne.NewSize(1200, 700))
window.SetFixedSize(true)

Dibujar Elementos Gráficos:

spot := canvas.NewRectangle(color.RGBA{R: 200, G: 200, B: 200, A: 255})
spot.Resize(fyne.NewSize(120, 80))
spot.Move(fyne.NewPos(x, y))

Manejar Imágenes y Animaciones:

car := canvas.NewImageFromResource(v.carEntering)
car.Resize(fyne.NewSize(120, 80))
car.Move(fyne.NewPos(gateX, gateY))

3.- Patrones de Diseño
Implementamos el Patrón Observer para mantener la comunicación entre el modelo de simulación y la interfaz gráfica, asegurando que cualquier cambio en el estado del estacionamiento se refleje automáticamente en la interfaz de usuario.

type Observer interface {
    Update(pos Position)
}

func (v *ParkingLotView) Update(pos models.Position) {
    // Manejo de actualizaciones
}

Consejos para Utilizar Fyne

Para aquellos que deseen comenzar a desarrollar aplicaciones con Fyne, aquí algunos consejos prácticos:

1.- Instalación de Fyne
Antes de comenzar, asegúrate de tener Go instalado en tu sistema. Luego, instala Fyne ejecutando:

go get fyne.io/fyne/v2

2.- Crear una Aplicación Básica
Aquí un ejemplo sencillo para iniciar una aplicación con Fyne:

package main

import (
    "fyne.io/fyne/v2/app"
    "fyne.io/fyne/v2/container"
    "fyne.io/fyne/v2/widget"
)

func main() {
    myApp := app.New()
    myWindow := myApp.NewWindow("Hola Fyne")

    hello := widget.NewLabel("¡Hola, Mundo!")
    myWindow.SetContent(container.NewVBox(
        hello,
    ))

    myWindow.ShowAndRun()
}

3.- Trabajar con Contenedores
Fyne utiliza contenedores para organizar los elementos de la interfaz. Algunos tipos comunes son:

VBox: Organiza los elementos verticalmente.

container.NewVBox(element1, element2)

HBox: Organiza los elementos horizontalmente.

container.NewHBox(element1, element2)

Grid: Organiza los elementos en una cuadrícula.

container.NewGridWithColumns(2, element1, element2)

4.- Manejar Eventos
Puedes añadir funcionalidad interactiva a tu aplicación manejando eventos como clics de botones:

button := widget.NewButton("Haz Clic", func() {
    // Acción a realizar cuando se hace clic
})

5.- Utilizar Recursos de Imágenes
Fyne permite cargar imágenes desde archivos locales para mejorar la interfaz gráfica:

carImage := canvas.NewImageFromFile("assets/car.png")
carImage.Resize(fyne.NewSize(100, 100))

6.- Actualizar la Interfaz de Usuario
Para reflejar cambios en la interfaz, utiliza el método Refresh:

carImage.Refresh()

7.- Animaciones Básicas
Aunque Fyne no tiene soporte nativo para animaciones complejas, puedes crear animaciones simples moviendo elementos en pasos incrementales:

go func() {
    for i := 0; i < 100; i++ {
        time.Sleep(time.Millisecond * 16) // Aproximadamente 60 FPS
        carImage.Move(fyne.NewPos(carImage.Position().X+1, carImage.Position().Y))
        carImage.Refresh()
    }
}()

Reflexiones Finales

El desarrollo del Simulador de Estacionamiento ha sido una experiencia enriquecedora que me permitió combinar conocimientos teóricos con la práctica de programación concurrente y diseño de interfaces gráficas. La elección de Go y Fyne demostró ser acertada, ya que ambas herramientas ofrecen potencia y flexibilidad para crear aplicaciones eficientes y visualmente atractivas.

Este proyecto no solo reforzó mi comprensión de conceptos clave como la concurrencia y los patrones de diseño, sino que también destacó la importancia de una buena planificación y la gestión efectiva de proyectos.

Para quienes deseen embarcarse en proyectos similares, recomiendo explorar la documentación de Fyne, experimentar con ejemplos básicos y poco a poco incorporar funcionalidades más complejas. La comunidad de Fyne es activa y ofrece numerosos recursos que pueden ser de gran ayuda.

En conclusión, el Simulador de Estacionamiento no solo cumplió con los objetivos académicos planteados, sino que también sirvió como una plataforma para desarrollar habilidades valiosas en programación y diseño de software, preparando el terreno para futuros desafíos en el mundo del desarrollo de aplicaciones.

¡Gracias por leer! Esperamos que este reporte sea útil para comprender mejor el proceso de desarrollo del simulador y para inspirar tus propios proyectos con Go y Fyne.

Referencias

Documentación de Go
Biblioteca Fyne
Patrones de Diseño de Software

Uso

Para ejecutar el simulador en tu máquina, sigue estos pasos:

1.- Clona el repositorio:

git clone https://github.com/Dariohg/parking_simulator.git cd parking-simulator

2.- Instala las dependencias de Fyne:

go get fyne.io/fyne/v2
3.- Ejecuta el simulador:

go run main.go
¡Disfruta simulando el funcionamiento de un estacionamiento!

Disclaimer

Este proyecto fue desarrollado con fines educativos y no está destinado para uso comercial o público.