De dónde partíamos: VuePress 1 y el tema Reco

Durante mucho tiempo, mi blog ha funcionado con VuePress 1 combinado con el tema Reco. Esta configuración, aunque funcional en su momento, fue quedándose obsoleta con el paso del tiempo.

Los problemas de la obsolescencia

Con el tiempo, surgieron varias dificultades:

1. Compatibilidad con Node.js: El tema Reco requería versiones antiguas de Node.js que ya no recibían soporte.
2. Falta de mantenimiento: El tema Reco dejó de recibir actualizaciones activas, lo que complicaba la incorporación de nuevas funcionalidades.
3. Rendimiento: Webpack, aunque potente, resultaba lento en los procesos de desarrollo.
4. Dependencias: Cada actualización de paquetes planteaba riesgos de romper la configuración existente.
5. Limitaciones de personalización: Modificar el tema Reco requería tocar node_modules, lo que era insostenible a largo plazo.

El gran salto tecnológico: VuePress 2 con Vite y Hope Theme

La solución pasaba por migrar a tecnologías modernas que ofrecieran mayor flexibilidad y rendimiento. Así, decidí adoptar VuePress 2 junto con el tema vuepress-theme-hope, y utilizar Vite como herramienta de construcción. La idea es no salir del ecosistema Vue, pero aprovechar las mejoras que estas nuevas herramientas ofrecen y que además se integran perfectamente con la arquitectura Jamstack y el renderizado del lado del servidor (SSR) que VuePress 2 implementa de forma nativa. Vue.js es una tecnología que domino y que me permite crear componentes personalizados para enriquecer la experiencia de los usuarios.

¿Qué es VuePress y cómo funciona?

VuePress es un generador de sitios web estáticos que combina Markdown con Vue.js. Cada página que escribes en Markdown se convierte en una aplicación Vue completa, lo que permite:

• Utilizar componentes Vue dentro del contenido Markdown.
• Personalizar cualquier aspecto del sitio con Vue.
• Generar sitios web estáticos de alto rendimiento.
• Implementar funcionalidades avanzadas como SSR, PWA y SEO de forma nativa.

¿Qué es el renderizado del lado del servidor (SSR)?

El SSR (Server-Side Rendering) es una técnica que permite renderizar las páginas en el servidor antes de enviarlas al navegador del usuario. VuePress utiliza esta arquitectura híbrida:

Beneficios del SSR:

• SEO mejorado: Los motores de búsqueda pueden indexar el contenido directamente.
• Carga más rápida: El usuario recibe HTML listo para mostrar.
• Mejor experiencia: La página es visible antes de que Vue tome el control.
• Accesibilidad: Mejor soporte para lectores de pantalla.

¿Qué es Jamstack?

Jamstack es una arquitectura moderna para crear sitios web rápidos y seguros. El nombre proviene de:

• JavaScript: Lógica del cliente
• API: Funcionalidad del servidor
• Markup: Contenido estático

Ventajas de Jamstack:

• Seguridad: No hay servidor que atacar.
• Escalabilidad: Servir archivos estáticos es muy económica.
• Rendimiento: CDN distribuida globalmente.
• Experiencia de desarrollador: Flujo de trabajo moderno con Git.
• Flexibilidad: Cualquier backend o API puede ser integrado.

VuePress es perfectamente compatible con esta arquitectura, generando archivos estáticos que pueden desplegarse en cualquier CDN.

¿Por qué Vite?

Vite es la herramienta de construcción de nueva generación que ha revolucionado el desarrollo frontend. Ha sido diseñada para ser rápida, eficiente y fácil de usar, superando las limitaciones de herramientas anteriores como Webpack. Vite utiliza ES Modules nativos en el navegador durante el desarrollo, lo que permite un arranque instantáneo y una experiencia de desarrollo fluida. Además, ha sido desarrollada por el mismo creador de Vue.js, lo que garantiza una integración perfecta con VuePress y Vue.js.

Ventajas principales:

| Característica | Webpack (antes) | Vite (ahora) | |

Embajador GitKraken

Me gusta GitKraken, como ya os dije. Ahora me han nombrado embajador. Es un reto apasionante poder representar y ayudar a usar esta suite que nos ofrece superpoderes para desarrollar nuestro código usando Git/GitHub. A la misma vez, me hace sentir muy feliz por mi centro, compañeros/as y alumnado, que se beneficiarán de ello. Y, sobre todo, me ilusiona poder ayudar y responder dudas que la comunidad me haga. Es un honor que una de las mejores herramientas existentes confíe en mí para esta labor.

¿Qué haré?

Pues es sencillo. Casi igual a lo que hago día a día. Intentaré aportar mi experiencia docente y como desarrollador. Con ello participaré en reuniones para dar mi opinión sobre funcionalidades de la herramienta. Luego estará mi labor para con la comunidad. Haré tutoriales de cómo usarla o ejemplos especiales de aspectos concretos que sean reseñables. Así que, si os interesa el material o simplemente os puedo ayudar en algo, no dudéis en contactar conmigo. Será un placer poder echaros un cable con ello. ¡Cuenta conmigo! 💪

Nos esperan grandes aventuras juntos y GitKraken será protagonista en ellas como gran herramienta que es y que me encanta utilizar.

Kit de embajador GitKraken

¡Mola! 😁 Ya me estoy imaginando lo bien que me quedarán esos calcetines. De hecho, estoy pensando en una falda escocesa a juego y dar mis ponencias, talleres y tutoriales en chanclas. La verdad es que me ha gustado y lo más importante es la confianza hacia mi labor y, por supuesto, mis calcetines 😎.

La decepción

Todo comenzó cuando no pude dar una clase que tenía preparada. Pero esa situación me llevó a investigar más, a profundizar en Kotlin y a descubrir herramientas y técnicas que ahora uso a diario en clase.

El aprendizaje

Las decepciones son oportunidades de mejora. Lo importante es no rendirse y usar esa frustración como combustible para mejorar.

Nuevo reconocimiento

Fruto de todo este trabajo, he obtenido la certificación de Kotlin Trainer por parte de JetBrains. Un reconocimiento que me llena de orgullo y que me compromete a seguir mejorando.

Gracias a todos los que me acompañáis en este viaje.

Ir más allá de Android

Kotlin es mucho más que un lenguaje para Android. De hecho, este es el gran error para quienes lo desconocen. Kotlin es un lenguaje moderno, ágil y potente para la JVM y más. Puedes usarlo como sustituto de Java para todos tus proyectos, desde hacer microservicios con Kotlin hasta hacer aplicaciones completamente multiplataforma.

Kotlin Expert

Kotlin Expert es una formación creada por Antonio Leiva dentro de las formaciones usando Kotlin que puedes encontrar en DevExperto. Antonio es formador en Kotlin certificado por JetBrains y Google Developer Expert.

El objetivo de esta formación es dar respuesta a las necesidades del sector donde los programadores Kotlin son cada vez más valorados para el desarrollo que va más allá de Android.

La formación es 100% práctica, en vídeo y materiales prácticos. Crea una App desde cero donde tanto el servidor como el cliente estarán programados en Kotlin.

Contenidos

• Módulo 1 - Conceptos básicos.
• Módulo 2 - Conceptos avanzados.
• Módulo 3 - Compatibilidad de Java.
• Módulo 4 - Servidor backend con Ktor.
• Módulo 5 - Cliente CLI.
• Módulo 6 - UI con Compose Desktop.
• Módulo 7 - Kotlin Multiplatform.
• Módulo 8 - APP Web con Kotlin/JS.
• Módulo 9 - Android con Kotlin Multiplatform.
• Módulo 10 - Kotlin Multiplatform Mobile e iOS.

Opinión personal

Desde hace poco soy certificador en tecnologías Kotlin por parte de JetBrains; además tengo el título de Kotlin Developer por JetBrains Academy. Sinceramente, te puedo garantizar que la formación que ofrece Antonio es de muchísima calidad y te centra en un solo curso lo que te supondría horas y meses de trabajo y formación.

Reflexiones del curso

Este año hemos trabajado duro en programación, resolviendo problemas reales y aprendiendo de nuestros errores. El resultado ha sido muy positivo: proyectos finales de gran calidad y un aprendizaje sólido.

Despedidas

A los que os vais, deciros que ha sido un placer acompañaros en este camino. Recordad que el aprendizaje no termina aquí, sino que empieza realmente ahora.

Hasta luego

Os deseo unas buenas vacaciones y mucho éxito en vuestra andadura profesional. Recordad que siempre podéis contactar conmigo para cualquier duda o recomendación.

¡Hasta luego!

Objetivos del curso

Este curso vamos a trabajar en mejorar la calidad del código, profundizar en patrones de diseño y arquitectura, y preparar al alumnado para el mundo laboral con proyectos realistas.

Nuevas tecnologías

Introduciremos Spring Boot para el desarrollo backend, Kubernetes para el despliegue y profundizaremos en Kotlin y su ecosistema.

Metodología

Seguimos con el aprendizaje basado en proyectos, donde el alumnado aprende resolviendo problemas reales del sector.

¡Mucho ánimo a todos!

Corrutinas

Las corrutinas son una característica de Kotlin que viene a facilitar la programación asíncrona y la reactividad de una manera muy sencilla. Si vienes de otros lenguajes ya conoces async/await de JavaScript o C# o los observables de RxJava y compañía. Las corrutinas permiten escribir código asíncrono de forma secuencial, ocultando la complejidad subyacente de las callbacks y el manejo de hilos.

La diferencia principal es que el hilo no se bloquea, sino que se suspende mientras espera el resultado de una operación. Esto es fundamental en aplicaciones donde la concurrencia y el rendimiento son importantes, como en aplicaciones móviles o servicios web.

suspend fun ejemplo() {
    val resultado = operacionAsincrona()
    println(resultado)
}

Scope y Context

Las corrutinas necesitan un contexto y un alcance (scope) para ejecutarse. El contexto incluye el Dispatcher que define en qué hilo se ejecuta la corrutina (Main, IO, etc.) y el alcance define el tiempo de vida de la corrutina.

val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())

Funciones suspend

Las funciones suspend son funciones que pueden ser pausadas y reanudadas. Solo pueden ser llamadas desde una corrutina u otra función suspend.

suspend fun getDatos(): Datos {
    return withContext(Dispatchers.IO) {
        baseDeDatos.obtener()
    }
}

async/await

Permite ejecutar varias operaciones en paralelo y esperar sus resultados.

val dato1 = async { getDatos1() }
val dato2 = async { getDatos2() }
println(dato1.await() + dato2.await())

Flows

Los Flows son secuencias asíncronas que pueden emitir múltiples valores, perfectos para el manejo de streams de datos.

fun getDatosFlow(): Flow<Datos> = flow {
    while (true) {
        emit(getDatos())
        delay(1000)
    }
}

Channels

Los channels permiten comunicación entre corrutinas de forma segura.

val channel = Channel<String>()
channel.send("mensaje")
val mensaje = channel.receive()

Las corrutinas han revolucionado la forma de programar en Kotlin, facilitando el manejo de operaciones asíncronas de forma clara y eficiente.

Antes de comenzar

Antes de nada, debo recordar que esto es mi web personal y que no representa al centro donde trabajo u otros centros donde he trabajado. No soy un portavoz de nadie más que de mí mismo. Si no estás de acuerdo con lo que digo, no te lo tomes a mal: es mi opinión y punto de vista, y lo expresaré de la forma más respetuosa posible.

Ser profesor y vivir de la enseñanza

Ser profesor de Formación Profesional es algo vocacional. Te dedicas más horas de las que querrías y de las que el sistema te da. Estás continuamente formándote (al menos los que nos dedicamos a esto) y sacrificas tu tiempo personal, que también lo necesitas.

Y como toda profesión, tiene su lado oscuro. El sistema está para ayudar, pero no lo hace. Las ratios son inasumibles, el apoyo insuficiente y la frustración va en aumento. Pero lo peor es cuando ves que no importas y que el sistema está más interesado en el papeleo que en el aprendizaje real.

Hoy me levanto pensando en qué puedo hacer para cambiar el sistema y me doy cuenta de que solo puedo cambiar una cosa: yo mismo. Puedo decidir cómo actuar a pesar de las circunstancias. Y así, empezaré a cuidarme un poco más.

Este será mi último curso dando clase. Ha sido una experiencia increíble, pero ha llegado el momento de decir basta. Me marcho a dedicar mi conocimiento y energía a otros proyectos donde sí se valore mi trabajo.

Gracias a todos los que me han apoyado en este camino. Sigue buscando formas de mejorar la educación, incluso cuando el sistema no coopera.

Reactividad: ¿esto qué es?

Vayamos por partes. O sigamos los pasos que hemos realizado en Programación de Servicios y Procesos este curso. La programación reactiva es un paradigma de programación que se basa en la reactividad. La reactividad es un concepto que se basa en la capacidad de reaccionar ante un estímulo. En el caso de la programación reactiva, se basa en la capacidad de reaccionar ante un cambio de estado. Y no es un unicornio mágico del que los desarrolladores hablemos por rincones oscuros de la web; es algo más simple y sencillo que combina distintas ideas y patrones de programación para conseguir ese resultado: reaccionar ante un cambio de estado.

¿Qué es un cambio de estado?

Por ejemplo, si estamos en nuestro timeline de Twitter/LinkedIn o red favorita y alguien nos menciona, nos llega un mensaje, nos llega una notificación, etc. ¿Estamos constantemente preguntando si nos han mencionado para mostrar esa notificación? ¡No! De alguna manera, delegamos esa acción y somos nosotros los que reaccionamos ante ese cambio de estado.

Patrón Observer y los eventos

Esto es tan viejo como el patrón Observer o el propio uso de los eventos. En el patrón Observer, tenemos un sujeto que es el que emite los cambios de estado y un observador que es el que reacciona ante esos cambios de estado. De hecho, lenguajes como Kotlin lo tienen incorporado en el sistema en varios tipos de delegados: observable o vetoable. En el caso de los eventos, tenemos un emisor de eventos y un receptor de eventos. En ambos casos, el emisor y el receptor no se conocen entre sí, pero ambos saben que el otro existe y que reaccionará ante un cambio de estado. ¿Lo ves? Lo llevas usando todo el tiempo y no lo sabías.

Aquí te dejo una simple implementación en Kotlin de un patrón Observer por si tienes curiosidad, usada en clase. Lo ves, ya sabes: reactividad.

// Una interfaz, podríamos usar genéricos
interface Publisher {
    fun onNews(news: String)
}

// Radio Una clase que implementa la interfaz
class RadioChannel : Publisher {
    override fun onNews(news: String) = println("La radio informa: $news")
}

// Periodico Una clase que implementa la interfaz
class Newspaper : Publisher {
    override fun onNews(news: String) = println("El periódico informa: $news")
}

// Agencia que es observada
class NewsAgency {
    // Lista de observadores, son los que implementan la interfaz
    private val listeners = mutableListOf<Publisher>()

    // Usamos los delegados que automáticamente, si detectan un cambio, avisan
    var news: String by Delegates.observable(initialValue = "") { _, old, new ->
        if (new != old) listeners.map { listener -> listener.onNews(new) }
    }

    // Añadimos un observador
    fun subscribe(publisher: Publisher) = listeners.add(publisher)

    // Eliminamos un observador
    fun unsubscribe(publisher: Publisher) = listeners.remove(publisher)
}

fun main() {
    // Preparamos los objetos observadores que reaccionarán ante un cambio de estado
    val radioChannel = RadioChannel()
    val newspaper = Newspaper()
    val newsAgency = NewsAgency()

    // Suscribimos a la agencia, me observan si cambio de estado
    newsAgency.subscribe(radioChannel)
    newsAgency.subscribe(newspaper)

    // Lanzamos una noticia. Al estar el delegado, la observa y automáticamente notifica
    // A mis observadores ante el cambio de estado, ¿lo ves?
    newsAgency.news = "¡Nadal Gana!"
    newsAgency.news = "¡Hoy llueve!"
    newsAgency.news = "¡Todos han aprobado!"

    // Los periódicos se retiran
    newsAgency.unsubscribe(newspaper)
    newsAgency.news = "Llegan las vacaciones :)"
}

Programación asíncrona

La programación asíncrona es un concepto que se basa en la ejecución de tareas de forma no síncrona. Esto quiere decir que no se tiene por qué ejecutar una detrás de otra en el mismo hilo de ejecución esperando una instrucción a la anterior para poder ejecutarse. La programación asíncrona nos da la capacidad de "diferir" la ejecución de una rutina a la espera de que se complete una operación, normalmente de I/O (red, disco duro, etc.), y así evitar bloquear la ejecución hasta que se haya completado la tarea en cuestión. Esto además nos permite ejecutar varias tareas a la vez de manera concurrente, sin tener que esperar a que una de ellas termine para poder ejecutar la siguiente.

¿Por qué es importante la asincronía para ser reactivos? ¿Sabes cuándo has de reaccionar? Por ejemplo, ¿debes bloquearte para ello si necesitas reaccionar si hay un cambio en la base de datos? Es por ello que la programación reactiva se basa en la programación asíncrona como uno de sus pilares fundamentales.

Procesamiento de colecciones

Y sí, procesar colecciones de manera asíncrona es fundamental para la reactividad; si no, ¿cómo vas a detectar el famoso cambio de estado ante distintos valores? Si tenemos una fuente de datos como una base de datos que puede cambiar, lo ideal es reaccionar ante el cambio y procesar esos datos de manera asíncrona.

Programación reactiva

Ahora sí estamos preparados para saber qué es la programación reactiva de acuerdo a su manifiesto.

La programación reactiva es un paradigma enfocado en el trabajo con flujos de datos (nuestras colecciones) finitos o infinitos de manera asíncrona con el objetivo de reaccionar al cambio de estado que pueda producirse en los mismos. Su concepción y evolución ha ido ligada a la publicación del Reactive Manifesto, que establecía las bases de los sistemas reactivos, los cuales deben ser:

• Responsivos: aseguran la calidad del servicio cumpliendo unos tiempos de respuesta establecidos.
• Resilientes: se mantienen responsivos incluso cuando se enfrentan a situaciones de error.
• Elásticos: se mantienen responsivos incluso ante aumentos en la carga de trabajo.
• Orientados a mensajes: minimizan el acoplamiento entre componentes al establecer interacciones basadas en el intercambio de mensajes de manera asíncrona.

Librerías de programación reactiva

Existen varias librerías de programación reactiva:

• Kotlin Flows: es la librería de Kotlin que te permite procesar flujos de datos de manera asíncrona y reaccionar ante el cambio de los mismos.
• Rx: fueron las pioneras en el desarrollo reactivo JS, .NET y Java/Kotlin, se encuentran completamente integradas en frameworks como Spring MVC, Spring Cloud y Netflix OSS.
• Reactor: Parte de RxJava 2. Esta API introduce los tipos Flux y Mono como implementaciones de Publisher.
• NgRx: es un marco para construir aplicaciones reactivas en Angular.
• LiveData es una clase de contenedor de datos observables. LiveData está optimizado para ciclos de vida.

Los que me conocen saben que soy muy pro Kotlin, por lo que te dejo una sencilla implementación de Kotlin Flows para procesar un RSS. Como puedes ver, esta vez no preguntamos activamente si hay noticias; simplemente observamos el flujo de datos y reaccionamos ante el cambio de estado asíncronamente; simplemente cuando lleguen o vayan llegando las procesamos.

Aplicaciones de programación reactiva

Entramos en la parte interesante: ¿cuáles son las aplicaciones de la programación reactiva? Pues si has seguido el artículo, en todo lo que implique reaccionar ante un cambio que no sabes cuándo se producirá y por lo tanto no puedes preguntar activamente por el mismo bloqueando el hilo principal.

Interactividad en aplicaciones

En aplicaciones de escritorio, móviles o web, la interactividad es un factor clave. La programación reactiva permite que las aplicaciones reaccionen ante los cambios de estado de manera asíncrona y sin bloquear el hilo principal.

Servicios reactivos

En servicios, la ejecución asíncrona y sin bloqueo y la E/S suelen ser más rentables mediante un uso más eficiente de los recursos. Ayuda a minimizar la contención en los recursos compartidos del sistema, que es uno de los mayores obstáculos para la escalabilidad, la baja latencia y el alto rendimiento.

Imagina un servicio que necesita realizar 10 solicitudes a una base de datos y esperar sus respuestas. Digamos que cada solicitud tarda 100 milisegundos. Si necesita ejecutarlas de manera secuencial síncrona, el tiempo total de procesamiento será de aproximadamente 1 segundo. Mientras que si es capaz de ejecutarlas todas de forma asíncrona, el tiempo de procesamiento será de solo 100 milisegundos.

Por otro lado, sabemos que los accesos a la base de datos con JDBC, por ejemplo, son bloqueantes; si conseguimos trabajar con drivers reactivos como R2DBC, podemos mejorar el rendimiento de nuestro servicio al no bloquear nunca la llamada.

Conclusiones

A lo largo de esta entrada he intentado acercaros a la programación reactiva, sus conceptos básicos y sus aplicaciones. No es algo tan temible y creo que podrás usarla en tus proyectos sin problemas. Para mí es fundamental en módulos como Acceso a Datos y Programación de Servicios y Procesos saber dominar los elementos clave detectando cuándo es necesaria y qué ventajas nos aporta.

Te invito a que te adentres en este mundo, sobre todo, que poco a poco lo integres en tu back o front y, por supuesto, en tus proyectos y clases.

El problema de copiar

Copiar no te hace más listo, te hace más dependiente. El día que tengas que enfrentar un problema real y no tengas a quién copiar, te darás cuenta de que no sabes resolver nada.

La reflexión

Si hubieras dedicado ese tiempo a entender el código, a buscar información, a preguntar, habrías aprendido de verdad. Y lo más importante, habrías desarrollado tu capacidad de resolver problemas.

El consejo

No te rindas. Todo el mundo comienza copiando. Lo importante es dar el paso de copiar a entender, y de entender a crear. Ese es el verdadero aprendizaje.

Recuerda: el único que sale perdiendo cuando copias eres tú mismo.

Introducción

Estos tutoriales tienen como objetivo mostrarte todo lo que aprenderás a través de los tracks de Hyperskill de JetBrains Academy. Hyperskill es el lugar perfecto para profundizar, ampliar tus conocimientos y aprender más sobre lo que se presenta en este tutorial.

Esta parte es un poco larga porque creamos toda la estructura de características increíbles de nuestro servicio. Tómalo con calma y visita Hyperskill para obtener más funciones geniales para tus servicios de Kotlin y Ktor.

DTOs y Mappers

Nuestro primer punto es mejorar las solicitudes y respuestas. Para lograr esto, introduciremos un patrón interesante: DTO (Data Transfer Object). Los DTO nos permiten transferir datos entre diferentes componentes de una aplicación, encapsulando la información de forma estandarizada.

Gracias a los DTO, podemos encapsular las solicitudes y respuestas mapeando entidades o diferentes tipos de datos entre ellos.

Validaciones y Páginas de Estado

Uno de nuestros problemas fundamentales es asegurarnos de que la información recibida sea correcta. No tiene sentido que nuestra raqueta tenga un precio negativo o que tengamos una marca o modelo vacío.

Para asegurar la corrección de la información entrante, utilizamos el complemento RequestValidation en Ktor. Este complemento nos permite validar el cuerpo de las solicitudes entrantes.

Almacenamiento Reactivo en la Base de Datos

Sabemos que tener un almacenamiento en memoria puede resultar tedioso. Implementemos nuestro repositorio para trabajar con una base de datos reactiva.

La diferencia principal entre JDBC y R2DBC radica en su enfoque y funcionamiento. JDBC es una API tradicionalmente utilizada en entornos Java para interactuar de manera síncrona con bases de datos relacionales. Sigue un enfoque de bloqueo.

Por otro lado, R2DBC es una API reactiva diseñada para la interacción asíncrona y reactiva con bases de datos relacionales. Permite operaciones de base de datos sin bloqueo.

El primer paso es seleccionar una biblioteca que nos ayude a programar con una base de datos reactiva. Utilizaremos Kotysa. Kotysa es un ORM ligero que ofrece una forma idiomática de escribir SQL seguro en términos de tipos de Kotlin utilizando el enfoque JDBC o R2DBC.

Codificando nuestros servicios

El siguiente paso es enriquecer el sistema de notificación en tiempo real con WebSockets y otras características avanzadas.

Railway Oriented Programming (ROP)

ROP es un concepto de programación funcional para manejar errores y componer operaciones secuenciales. Organiza las operaciones en una secuencia de pasos, donde cada paso puede tener éxito y continuar al siguiente paso en el camino deseado o fallar y dirigirse a un camino de manejo de errores.

Testing

Ahora entramos en una parte crucial y esencial: probar nuestro código. Para hacer esto, haremos uso de JUnit. JUnit es un marco de pruebas de código abierto ampliamente utilizado para aplicaciones Java.

Puedes encontrar el código de este proyecto en GitHub. Por favor, no olvides darle una estrella o seguirme para estar al tanto de nuevos tutoriales y noticias.

Puedes seguirlo commit por commit y utilizar el archivo de respaldo de Postman para probarlo.

Recuerda que este no es un código para usar en un entorno real o de producción. Es un proyecto didáctico para que puedas experimentar, analizar, mejorar o adaptar a tu forma de programar.

Las siguientes pistas ofrecidas por JetBrains Academy en Hyperskill pueden ser un punto de partida perfecto:

• Desarrollador Kotlin
• Desarrollador Backend Kotlin (Ktor)

Introducción

En esta tercera parte vamos a completar nuestro servicio API REST reactivo abordando los últimos temas avanzados que nos faltan por ver.

Inyección de Dependencias con Koin

Koin es un marco de inyección de dependencias pragmático y ligero escrito en Kotlin. Proporciona una forma nativa de Kotlin de inyectar tus dependencias sin generación de código.

Conexiones Seguras con SSL/TLS

La seguridad es fundamental en cualquier aplicación. Vamos a configurar SSL/TLS para asegurar nuestras conexiones.

Autenticación y Autorización con JWT

JSON Web Token (JWT) es un estándar abierto para transmitir información de forma segura entre partes. Vamos a implementar autenticación y autorización con JWT.

Documentación con Swagger y OpenAPI

Swagger es una especificación para describir APIs RESTful. OpenAPI es la evolución de Swagger. Vamos a documentar nuestro servicio.

Despliegue con Docker

Docker nos permite empaquetar nuestra aplicación con todas sus dependencias en un contenedor portable.

Conclusión

Hemos completado nuestra serie de tutoriales sobre cómo crear una API REST reactiva con Kotlin y Ktor. Ahora tienes una base sólida para seguir desarrollando.

Puedes encontrar el código de este proyecto en GitHub. No olvides darle una estrella para estar al tanto de nuevos tutoriales.

Las siguientes pistas ofrecidas por JetBrains Academy en Hyperskill pueden ser un punto de partida perfecto:

• Desarrollador Kotlin
• Desarrollador Backend Kotlin (Ktor)

El martes 7 de noviembre de 2023, Antonio Leiva, CEO de DevExpert.io, visitó el IES Luis Vives para impartir una charla dirigida al alumnado de la familia de informática. La expectación era alta y el evento resultó ser todo un éxito, ya que el salón de actos se llenó por completo de alumnado y profesorado que querían disfrutar de la visita de Antonio.

Mi foco principal es el desarrollo de aplicaciones web y multiplataforma, desde el servidor ⚙️ hasta el cliente 📱. Imparto docencia en másteres, doctorado y cursos de especialización en diseño, desarrollo y evaluación de productos de software. Me apasiona el ecosistema de Kotlin, .NET y Vue.js 💓.

Aparte de mi docencia diaria, imparto formación en cursos de máster/doctorado y programas de especialización o grupos de trabajo. Mi especialidad es el diseño, desarrollo y evaluación de la experiencia de usuario y productos interactivos, usabilidad, accesibilidad y, sobre todo, jugabilidad. Colaboro en distintos proyectos de investigación y desarrollo. Soy formador en nuevas tecnologías y metodologías de desarrollo de aplicaciones web, desarrollo de servicios, multiplataforma, web o móviles (siempre centradas en el usuario). Me encanta evaluar y poder ayudarte a mejorar tus productos interactivos y aprender de lo que haces 🙂.

Personalmente, he sido galardonado con distintos premios y distinciones a lo largo de mi carrera profesional, que podrás conocer en la sección de Investigación.

Me siento orgulloso de ser Kotlin Trainer Certified by JetBrains y GitHub Campus Advisor. Te puedo ayudar a aplicar superpoderes para desarrollar nuestro código o a cómo aplicarlos a la docencia. Actualmente, soy uno de los responsables de contenidos en Hyperskill/JetBrains Academy para tecnologías relacionadas con Kotlin. Será un placer echarte un cable con ello. ¡Cuenta conmigo! 💪

En esta página web podrás conocer un poco más de mí.

Aficiones

Aparte de enseñar y desarrollar, disfruto con la música, especialmente todo tipo de música rock 🎵 , me encanta el tenis 🎾, tocar la guitarra 🎸, jugar a videojuegos 🎮, leer 📚 , ver series/películas/anime 📺 y compartir buenos momentos (¿una caña y una buena charla?🍺). Me encanta seguir aprendiendo y seguir avanzando.

Contacto

Cualquier cosa que necesites házmelo saber por si puedo ayudarte 💬.

Una cita

«Programa siempre tu código como si el tipo que va a tener que mantenerlo en el futuro fuera un violento psicópata que sabe dónde vives».

Martin Goldin

Este curso, he decidido pasarme a la plataforma .NET con C#. No es una decisión tomada a la ligera. Es una respuesta crítica y meditada a los retos que tenemos como docentes en este nuevo panorama educativo y profesional.

Antes de terminar este año 2025 y comenzar el 2026, quiero compartir con vosotros las razones detrás de este cambio y cómo .NET no solo es una plataforma robusta y moderna, sino también una herramienta pedagógica excepcional.

Te voy a dejar mis 20 razones para este cambio de paradigma en la docencia de DAW.

1. Nueva FP: ¿Por qué Kotlin ya no es suficiente?

Aunque Kotlin es un lenguaje moderno y expresivo, capaz de tocar de manera clara todos los paradigmas y conceptos de la programación, su ecosistema sigue siendo más limitado. Es un lenguaje que ha experimentado un crecimiento significativo en los últimos años, especialmente en el desarrollo de aplicaciones Android y backend con Ktor o Spring Boot en todo el mundo. Sin embargo, su adopción en el mercado laboral español, especialmente en el ámbito empresarial, sigue siendo limitada en comparación con otras tecnologías más establecidas como .NET y JVM.

Antes, sin la fase de formación en empresas en primero, podía permitirme el lujo de enseñar Kotlin, centrándome en los conceptos fundamentales de la programación y dejando que los alumnos se adaptaran a las tecnologías específicas del mercado en segundo o durante sus prácticas. Kotlin es el mejor lenguaje puente para luego saltar a Java, C#, TypeScript, Swift o incluso Python. El objetivo era claro: enseñar a pensar en código, no en tecnologías específicas, y en segundo especializarnos en las tecnologías más demandadas con una base sólida y trabajada en primero.

El nuevo calendario de FP exige que los alumnos estén listos para formarse en empresas desde el primer año, con suerte. De hecho, ya no formamos tanto: se cede parte de esa formación a las empresas (y perdonad que siga sin creérmelo, por lo menos en esta especialidad y en estos días; ojalá en el futuro cambie). Aparte, tenemos el problema de las horas y si van todos los alumnos, si no van, adónde van, etc. Un caos didáctico que me obliga a priorizar y buscar el equilibrio entre seguir transmitiendo una base sólida de programación y preparar a los alumnos para que al menos puedan desenvolverse en la Fase de Formación en Empresas. Pero ya tenemos menos horas en primero y segundo, por lo que debo priorizar.

Debido a que yo no puedo asegurar la formación, ni horas ni a las empresas adonde van a ir los alumnos o simplemente saber qué contenidos trabajarán en la empresa (y si los van a trabajar realmente), debo asegurarme de que los conocimientos que adquieran en el aula sean directamente aplicables en el entorno laboral de una forma más directa. Y ahí es donde .NET brilla sobre Kotlin, por lo menos en España.

C# y .NET ofrecen un equilibrio perfecto entre modernidad, robustez y demanda laboral. Permiten a los alumnos aprender conceptos fundamentales de programación (según mi punto de vista) mientras se preparan para un mercado que valora estas habilidades.

Quiero destacar que no soy un novato de C# y .NET; de hecho gané un premio con C# junto a mi equipo, Microsoft Imagine Cup España 2007 en la especialidad de «Software Design» ver, pasé a Kotlin porque es la leche, y soy formador/certificador con JetBrains a nivel mundial y ahora vuelvo a C#. He visto la evolución de ambos lenguajes y plataformas, y creo que .NET ha madurado de una manera que lo hace ideal para la enseñanza en DAW actual, bajo mi filosofía de aprendizaje. Creo que mi experiencia me permite hacer esta afirmación con fundamento y objetividad.

Ventajas clave de C# y .NET para 1.º DAW

2. El «Muro de Entrada»: La pedagogía del punto de entrada

Sabemos que Java es poderoso, pero que le cuesta evolucionar y que otros lenguajes han tomado la delantera en términos de características modernas. Sin embargo, uno de los mayores errores de Java ha sido su incapacidad para adaptarse a una enseñanza gradual, para ir conociendo todos los paradigmas y fundamentos algorítmicos. Para que un alumno escriba su primera línea de código en Java, tiene que realizar un «acto de fe» masivo. Tiene que escribir una clase, un método estático y entender qué es un array de strings.

Java (El peso de la herencia): Para explicar esto, tengo que adelantar conceptos de programación orientada a objetos (clases), visibilidad (public) y contexto estático (static) y ver que hay un array de strings (String[] args) cuando el alumno aún no sabe qué es una variable y solo quiere escribir su primera línea de código.

public class Main {
    public static void main(String[] args) {
        System.out.println("¿Por qué tengo que escribir todo esto y para qué sirve?");
    }
}

Incluso con las mejoras recientes (JEP 445), Java lucha por ocultar su complejidad, pero la estructura subyacente sigue asomando de forma prematura, enseñando lo que es un método main antes de que el alumno entienda la lógica básica.

void main() {
    System.out.println("Pero sigo necesitando un método main y no lo he visto antes");
}

En cambio, C# con Top-Level Statements permite seguir el orden lógico del razonamiento humano: Estructurada -> Modular -> Objetos -> Funcional. Empezamos con la lógica, y el resto viene después, cuando el alumno está preparado. Sin duda es más eficiente pedagógicamente: no necesitas ni un método main.

C# (Moderno):

// Directo, limpio, sin ruido.
Console.WriteLine("Aquí empieza la lógica, no la burocracia");

Modularidad sin redundancia

Mientras Java intenta simplificar su sintaxis, C# ya ofrece un ecosistema maduro donde la modularidad es limpia y potente. Un ejemplo claro es la gestión de parámetros: en lugar de obligar al alumno a aprender la sobrecarga de métodos (escribir el mismo método varias veces con distintos argumentos), C# utiliza parámetros opcionales y nombrados.

Esto no solo es más fácil de enseñar, sino que es más eficiente en el mundo real.

// Una sola definición cubre múltiples escenarios
void Saludar(string nombre = "Mundo", int veces = 1) 
{
    for (int i = 0; i < veces; i++) 
    {
        Console.WriteLine($"Hola, {nombre}!");
    }
}

// Flexibilidad total en la llamada:
Saludar();                         // Usa valores por defecto
Saludar("Ana", 3);                 // Argumentos posicionales
Saludar(veces: 5, nombre: "Luis"); // Argumentos nombrados: claridad absoluta

Además, C# permite un control granular de la memoria y la intención mediante modificadores de parámetros que Java no posee de forma equivalente:

• out: Para devolver múltiples valores de forma explícita.
• ref: Para paso por referencia real (no solo de la referencia al objeto).
• in: Para asegurar que un parámetro es de solo lectura, optimizando el rendimiento en estructuras grandes.

3. Tipado fuerte y explícito desde el principio

C# es un lenguaje fuertemente tipado, lo que significa que los tipos de datos son explícitos y claros desde el principio. Esto ayuda a los alumnos a comprender mejor cómo funcionan los datos y las operaciones en programación, así como a evitar errores comunes relacionados con tipos de datos y conversiones implícitas.

int numero = 10; // Tipo explícito
string texto = "Hola, Mundo"; // Tipo explícito
double decimalNumero = 15.5; // Tipo explícito

// Inferencia de tipos con 'var'
var otroNumero = 20; // El compilador infiere que es int
var otroTexto = "Adiós, Mundo"; // El compilador infiere que es string

4. Seguridad ante nulos: Compilación frente a tiempo de ejecución

Para mí esto es fundamental, y más aún si este control es a nivel de compilación. El NullPointerException es el cáncer del aprendizaje. Java intentó solucionarlo con Optional, pero es un parche verboso que ensucia el código. En C#, el control de nulos es nativo y ocurre en tiempo de compilación y de manera elegante.

La verbosidad de Java con Optional:

Optional<String> nombre = Optional.ofNullable(alumno.getNombre());
String resultado = nombre.map(String::toUpperCase).orElse("SIN NOMBRE");

La elegancia de C# (Null Safety nativo): En C#, si una variable puede ser nula, lleva un ?. Si no, el compilador te avisa. Es el mismo poder que me enamoró de Kotlin.

string? nombre = alumno.Nombre;
string resultado = nombre?.ToUpper() ?? "SIN NOMBRE"; // El compilador me protege

5. Propiedades: encapsulamiento sin el ruido

En Java, el encapsulamiento requiere escribir métodos get y set, lo que añade ruido y complejidad innecesaria, salvo que uses librerías de terceros como Lombok. C# introduce propiedades que permiten un acceso limpio y controlado a los campos, manteniendo el encapsulamiento sin la verbosidad, muy similar a Kotlin.

Java (Verbosidad):

public class Alumno {
    private String nombre;
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

C# (Propiedades limpias):

public class Alumno {
    public string Nombre { get; set; } // Encapsulamiento sin ruido
}

Podemos indicar que una propiedad es de solo lectura o escritura, usando get; o set; según convenga, o si es inmutable usando init; o la visibilidad, por ejemplo, que no se pueda modificar desde fuera de la clase con private set;.

public class Alumno {
    public string Nombre { get; private set; } // Solo lectura desde fuera
    public int Edad { get; init; } // Inmutable después de la inicialización
}

var alumno = new Alumno { Nombre = "Luis", Edad = 20 };

Finalmente, con las Backing Fields, podemos tener lógica adicional en las propiedades sin perder la simplicidad, o usar campos calculados si es necesario.

public class Alumno {
    public string Nombre { get; private set; } // Solo lectura desde fuera
    public int Edad { 
        get => field;
        // Podemos usar init para inmutabilidad después de la inicialización, pero lo dejamos con set para este ejemplo
        set {
            if (value < 0) throw new ArgumentException("La edad no puede ser negativa");
            field = value;
        }
    }
}

6. Tuplas, estructuras, clases y registros: elección según la necesidad

C# ofrece estructuras (structs) para datos ligeros (en el stack) y clases para objetos complejos, además de registros (records) para inmutabilidad y comparación por valor. Esto permite enseñar a los alumnos a elegir la herramienta adecuada según el caso, fomentando un diseño de software más consciente. Lo mejor de las clases y data classes de Kotlin juntos. Y además, los registros son inmutables por defecto, lo que fomenta buenas prácticas de programación funcional.

Si no, tienes las tuplas para datos temporales y ligeros, ideal para devolver múltiples valores sin crear una clase específica.

public struct Punto {
    public int X { get; set; }
    public int Y { get; set; }
}

public record Alumno(string Nombre, int Edad); // Inmutable y por valor

var punto = new Punto { X = 10, Y = 20 };
var alumno = new Alumno("Juan", 20);
var otroAlumno = alumno with { Edad = 21 }; // Nuevo objeto con cambio

// Tuplas para múltiples valores
(int suma, int producto) Calcular(int a, int b) {
    return (a + b, a * b);
}

// Usamos desestructuración
var (suma, producto) = Calcular(3, 4);

7. Inicializadores con propiedades o constructores con parámetros nombrados y valores por defecto

C# permite inicializar objetos usando inicializadores de propiedades, lo que hace que el código sea más limpio y fácil de leer, de forma similar a las data classes de Kotlin.

var alumno = new Alumno {
    Nombre = "Ana",
    Edad = 22
};

Además, los constructores en C# pueden tener parámetros nombrados y valores por defecto, lo que facilita la creación de objetos sin necesidad de múltiples sobrecargas de constructores, cosa que ya hemos visto antes.

public class Alumno {
    public string Nombre { get; set; }
    public int Edad { get; set; }

    public Alumno(string nombre = "Desconocido", int edad = 18) {
        Nombre = nombre;
        Edad = edad;
    }
}

var alumno = new Alumno(edad: 22); // Nombre por defecto, Edad especificada

Finalmente, tenemos constructores primarios, ideales para ir al grano cuando queremos definir clases inmutables o registros.

public class Alumno(string nombre, int edad) {
    public string Nombre { get; } = nombre;
    public int Edad { get; } = edad;
}
var alumno = new Alumno("Luis", 20);

8. LINQ: el lenguaje de las colecciones que habla SQL

Los Streams de Java son potentes, pero su sintaxis es alienígena para alguien que está aprendiendo bases de datos. LINQ en C# es el puente perfecto. Su similitud con SQL es tan grande que los alumnos aprenden ambos conceptos a la vez.

Ejemplo comparativo de procesamiento de datos:

Imagina esto en Java:

// Streams: Verboso y menos intuitivo
List<Alumno> aprobadas = listaAlumnos.stream()
    .filter(a -> a.getNota() >= 5)
    .sorted(Comparator.comparing(Alumno::getApellidos))
    .map(a -> new AlumnoDTO(a.getNombre() + " " + a.getApellidos(), a.getNota()))
    .collect(Collectors.toList());

// LINQ: Parecido a SQL, fácil de razonar
var aprobadas = listaAlumnos
    .Where(a => a.Nota >= 5)
    .OrderBy(a => a.Apellidos)
    .Select(a => new AlumnoDTO($"{a.Nombre} {a.Apellidos}", a.Nota))
    .ToList();

Aparte de todo esto, C# y .NET ofrecen muchas colecciones y estructuras de datos listas para usar, lo que facilita la enseñanza de algoritmos y estructuras fundamentales sin tener que reinventar la rueda, ya sean listas, diccionarios, conjuntos, pilas o colas, todas con una sintaxis coherente y fácil de entender, además de sus versiones inmutables y concurrentes.

9. Programación funcional, extensiones y pattern matching

Java mete la programación funcional con calzador. Es demasiado verboso y poco intuitivo.

C# la abraza, ofreciendo características que hacen que el código sea más expresivo y limpio como pasaba con Kotlin.

• Funciones de extensión: me permiten «limpiar» el código y extender sin heredar. De lo que más usaba en Kotlin.
• Pattern Matching: permite descomponer y analizar datos de forma clara y concisa.
• Sobrecarga de operadores: permite definir cómo se comportan los operadores para tipos personalizados, haciendo el código más intuitivo.

C# (Poder expresivo):

// Función de extensión + Pattern Matching + Switch Expression
public static string Categorizar(this double nota) => nota switch
{
    >= 9 => "Sobresaliente",
    >= 7 => "Notable",
    >= 5 => "Aprobado",
    _    => "Suspenso"
};

// Uso:
double miNota = 8.5;
Console.WriteLine(miNota.Categorizar()); // Imprime: Notable

10. Genéricos con «guardas» (constraints)

En Java, los genéricos son «borrados» en tiempo de ejecución (type erasure). En C#, son reales y, lo más importante, se pueden restringir. Esto permite enseñar diseño de software de alto nivel.

// Solo aceptamos tipos que sean clases y tengan constructor
public class Almacen<T> where T : class, new() 
{
    public T GetNuevo() => new T();
}

11. Interoperabilidad total con otras plataformas

C# y .NET ofrecen una interoperabilidad excepcional con otras plataformas y lenguajes, lo que permite a los alumnos trabajar en entornos mixtos sin problemas. Esto es especialmente útil en proyectos empresariales donde la integración con sistemas existentes es común.

12. Ficheros y serialización simplificada

Al contrario de Java, que requiere librerías externas para muchas tareas comunes, C# y .NET incluyen soporte nativo para trabajar con ficheros y serialización (JSON, XML) de manera sencilla y directa tal y como ocurre en Kotlin.

// Leer y escribir JSON nativo
var alumno = new Alumno { Nombre = "Luis", Edad = 23 };
string json = JsonSerializer.Serialize(alumno);
var alumnoRecuperado = JsonSerializer.Deserialize<Alumno>(json);

13. Bases de Datos

Podemos usar las ventajas de ADO.NET para conexiones directas o Entity Framework Core para un ORM potente y moderno. EF Core permite trabajar con bases de datos relacionales usando LINQ, lo que facilita la enseñanza de conceptos de bases de datos y programación al mismo tiempo.

Ejemplo con ADO.NET:

using (var conexion = new SqlConnection(cadenaConexion)) {
    conexion.Open();
    var comando = new SqlCommand("SELECT * FROM Alumnos WHERE Edad > @edad", conexion);
    comando.Parameters.AddWithValue("@edad", 18);
    using (var lector = comando.ExecuteReader()) {
        while (lector.Read()) {
            Console.WriteLine($"{lector["Nombre"]} - {lector["Edad"]}");
        }
    }
}

Ejemplo con Entity Framework Core:

public class Alumno {
    [Key]
    public int Id { get; set; }
    [Required]
    public string Nombre { get; set; }
    [Range(0, 120)]
    public int Edad { get; set; }
}

public class EscuelaContext : DbContext {
    public DbSet<Alumno> Alumnos { get; set; }
}

var contexto = new EscuelaContext();
var alumnos = contexto.Alumnos
    .Where(a => a.Edad > 18)
    .ToList();

14. Interfaces de usuario: muchas opciones para todos los niveles

C# y .NET ofrecen múltiples opciones para crear interfaces de usuario, desde aplicaciones de consola hasta aplicaciones web y de escritorio. Esto permite adaptar la enseñanza según el nivel del alumno y el contexto del proyecto transmitiendo conceptos de estado de la interfaz, eventos y, si es necesario, patrones de diseño como MVVM o MVC.

15. Testing con NUnit y Moq

C# tiene un ecosistema de testing muy maduro con frameworks como NUnit para pruebas unitarias y Moq para mocking. Esto facilita la enseñanza de buenas prácticas de desarrollo y asegura que los alumnos comprendan la importancia de las pruebas en el desarrollo de software.

[TestFixture]
public class AlumnoServiceTests {
    [Test]
    public void TestRegistrarAlumno() {
        var servicio = new AlumnoService();
        var resultado = servicio.Registrar(new Alumno { Nombre = "Test" });
        Assert.IsTrue(resultado);
    }
}

Ventajas clave de C# y .NET para 2.º DAW

Aquí viene el gran cambio, pues uno de mis objetivos era enseñar tres entornos: JVM (SpringBoot), .NET (ASP.NET Core) y PHP (Laravel). Y así fue hasta el año pasado. Este será el último año que lo haga; de hecho, ya ha desaparecido PHP. Por lo que solo me centraré en JVM y .NET a nivel de servicios y páginas web dinámicas. El motivo es que no hay tiempo: puedes tener alumnos que no han hecho la fase de formación en empresas de primero y a los que se les suman las horas de segundo. Un caos que de nuevo me obliga a priorizar. Más vale poco bien hecho que mucho mal hecho. Además, no salir de .NET me permite profundizar más y mejor en un solo ecosistema.

16. Asincronía, reactividad y ROP: las bases del backend moderno

Enseñarle a un alumno CompletableFuture en Java es invitarle a dejar la programación (sé que he exagerado), pero debes unirle lo que es el ExecutorService. En C#, el modelo async/await es tan transparente que la programación asíncrona deja de ser un «muro» para ser una herramienta más. Muy similar a lo que pueden encontrar en JavaScript/TypeScript.

Asincronía limpia:

public async Task<Alumno> GetAlumnoAsync(int id) 
{
    var response = await _client.GetAsync($"/api/alumnos/{id}");
    return await response.Content.ReadFromJsonAsync<Alumno>();

}

Reactividad y LINQ: Podemos usar colecciones asíncronas o reactivas dependiendo si queremos un patrón «pull» o «push». Además, con LINQ podemos transformar flujos de datos de manera declarativa.

// Patrón Pull (IAsyncEnumerable):
public async IAsyncEnumerable<Alumno> GetAlumnosAsync() {
    var response = await _client.GetAsync("/api/alumnos");
    var alumnos = await response.Content.ReadFromJsonAsync<List<Alumno>>();
    foreach (var alumno in alumnos) {
        yield return alumno;
    }
}

// Patrón Push (IObservable):
public IObservable<Alumno> GetAlumnosObservable() {
    return Observable.Create<Alumno>(async observer => {
        var response = await _client.GetAsync("/api/alumnos");
        var alumnos = await response.Content.ReadFromJsonAsync<List<Alumno>>();
        foreach (var alumno in alumnos) {
            observer.OnNext(alumno);
        }
        observer.OnCompleted();
    });
}

var alumnosAsync = GetAlumnosAsync().Where(a => a.Edad >= 18)
    .Select(a => new { a.Nombre, a.Edad } );

await foreach (var alumno in alumnosAsync) {
    Console.WriteLine($"{alumno.Nombre} - {alumno.Edad}");
}

var alumnosObservable = GetAlumnosObservable()
    .Where(a => a.Edad >= 18)
    .Select(a => new { a.Nombre, a.Edad });

alumnosObservable.Subscribe(alumno => 
    Console.WriteLine($"{alumno.Nombre} - {alumno.Edad}"));

ROP: adiós al Try-Catch infinito C# permite implementar el patrón de «vía de tren». Si algo falla, el flujo se desvía, pero el código sigue siendo una línea recta. Los errores de dominio no son excepciones: son datos.

public Result<Alumno> Registrar(AlumnoRequest req) =>
    .Ensure(r => ValidarDatos(r))
    .Bind(r => ComprobarDuplicados(r))
    .Bind(r => GuardarEnBD(r))
    .Bind(r => EnviarEmailBienvenida(r))
    .Tap(alumno => Log.Info($"Alumno registrado: {alumno.Id}"));


var resultado = servicio.Registrar(req)
    .Match(
    alumno => Console.WriteLine($"Alumno registrado: {alumno.Id}"),
      error => Console.WriteLine($"Error: {error.Mensaje}")
);

La Máquina Virtual de Java (JVM) es un estándar indiscutible en el desarrollo empresarial y de alto tráfico gracias a su rendimiento estable, su capacidad de escalabilidad horizontal (manejo de miles de hilos) y su robusto ecosistema de herramientas.

Spring Boot es el framework de referencia en este ecosistema. Ofrece una solución completa para simplificar la configuración, implementar la Inyección de Dependencias (DI) y abordar de forma modular aspectos complejos como la Seguridad, el Acceso a Datos y la Comunicación Asíncrona. Su filosofía es la "convención sobre la configuración", lo que acelera dramáticamente el desarrollo.

Esta unidad de 2.º DAW te enseñará a construir APIs REST de nivel industrial, cubriendo desde la arquitectura Java hasta la optimización con caché Redis y la seguridad JWT.

1. Proyecto del Curso 🚀

El Proyecto es el eje central de la unidad. Aquí se integran todos los conocimientos adquiridos para construir una API REST completa y robusta de nivel de producción. Servirá como tu porfolio de backend profesional.

Link al repositorio del Proyecto completo: https://github.com/joseluisgs/DesarrolloWebEntornosServidor-02-Proyecto-SpringBoot

Comprender la inmutabilidad y el modelo de paso por referencia de estas estructuras en el lenguaje C# es esencial para evitar errores comunes y escribir código robusto.

1. Arrays: La Base del Almacenamiento Estático

Un array es una estructura de datos fundamental que almacena una colección ordenada de elementos del mismo tipo.

1.1. Características Clave

Los arrays en DAW son estructuras de datos muy eficientes, caracterizadas por:

• Homogeneidad (Tipo Fijo): Todos los elementos son del mismo tipo de dato.
• Tamaño Fijo (Inmutabilidad): El tamaño se establece al crearse y no puede alterarse. Si se requiere un tamaño diferente, se debe crear un nuevo array y copiar los datos.
• Contigüidad en Memoria: Los elementos se almacenan en posiciones de memoria contiguas, lo que garantiza su alta eficiencia.
• Acceso por Índice: El acceso a cualquier elemento se realiza mediante su índice, proporcionando un tiempo de acceso constante ($O(1)$).

1.2. Indexación y Tipos de Referencia

En C#, la indexación es cero-basada, es decir, el primer elemento se encuentra en el índice 0. Acceder a un índice fuera de los límites (negativo o mayor o igual al tamaño) produce una excepción (IndexOutOfRangeException).

Crucialmente, los arrays son tipos de referencia en C#. Esto implica que:

• Al pasar un array a una función, se pasa una copia de su dirección de memoria (referencia).
• Cualquier modificación a los elementos dentro de la función afecta al array original.
• Para obtener una copia verdaderamente independiente, se debe realizar una Clonación Manual (copia profunda), creando un nuevo array y copiando los valores elemento por elemento.

2. Arrays Multidimensionales (Matrices) y Técnicas Avanzadas

Los arrays multidimensionales (matrices) extienden el concepto del array unidimensional para manejar estructuras de datos con múltiples dimensiones, como tablas o rejillas (filas y columnas).

2.1. Gestión de la Identidad y Clonación

En las matrices, el concepto de referencia se vuelve más complejo.

• Identidad (==): El operador == solo compara si dos matrices apuntan a la misma dirección de memoria (Identidad), no si tienen el mismo contenido.
• Clonación Profunda: Una simple asignación o copia superficial resulta en una doble referencia. Para obtener una copia realmente independiente de una matriz, se requiere una Clonación Profunda Manual, que implica copiar tanto las referencias de las filas como los valores internos de cada elemento.

2.2. Doble Búfer (Double Buffering)

El Double Buffering es una técnica avanzada esencial para la simulación y la animación.

• Teoría: Consiste en usar dos matrices (búfer frontal y búfer trasero). Mientras el búfer frontal se muestra al usuario, los cálculos y modificaciones se aplican en el búfer trasero.
• Eficiencia: Una vez completado el cálculo, el mecanismo de intercambio (Swap) simplemente intercambia las referencias (punteros) de los dos búferes. Esta operación es de tiempo constante ($O(1)$), mucho más eficiente que copiar todos los datos (que sería $O(n^2)$).

3. Cadenas de Texto (string) y Expresiones Regulares

Las cadenas de texto son, fundamentalmente, arrays de caracteres, pero con una característica crucial: la inmutabilidad.

3.1. Inmutabilidad y Rendimiento con StringBuilder

• Inmutabilidad: Una vez que una cadena (string) se ha creado, no puede ser modificada. Cada operación de concatenación (+) o modificación crea una nueva cadena en memoria.
• Rendimiento: Para operaciones intensivas de manipulación o concatenación de texto, el uso repetido del operador + es ineficiente.
• StringBuilder: Es una clase diseñada para construir cadenas de manera mutable. Almacena la cadena internamente y solo crea el objeto string final cuando se solicita, optimizando el rendimiento.

3.2. Expresiones Regulares (Regex)

Las expresiones regulares son secuencias de caracteres que definen un patrón de búsqueda.

• Funcionalidad: Se usan para tareas como la validación de formatos (ej. email, DNI), la búsqueda de patrones complejos y la sustitución de texto.
• Conceptos Clave: Se basan en metacaracteres que representan conjuntos de caracteres o cuantificadores (ej. . para cualquier carácter, + para una o más ocurrencias).

4. Algoritmos de Ordenación (Sorting) y Búsqueda (Searching)

4.1. Algoritmos de Ordenación

La ordenación es el proceso de organizar los elementos de una colección siguiendo un orden específico (ascendente o descendente).

• Burbuja (Bubble Sort): Intercambia pares de elementos adyacentes si están en el orden incorrecto. Es simple pero ineficiente ($O(n^2)$).
• Selección (Selection Sort): Encuentra repetidamente el elemento mínimo (o máximo) y lo coloca en la posición inicial no ordenada. También ineficiente ($O(n^2)$).
• Inserción (Insertion Sort): Construye la matriz final un elemento a la vez, insertando el elemento actual en su posición correcta dentro de la sub-matriz ya ordenada.
• Rápida (QuickSort): Utiliza una estrategia de "divide y vencerás". Elige un elemento pivote y particiona la matriz en dos sub-arrays, con los elementos menores al pivote en un lado y los mayores en el otro. Es el método más rápido en promedio ($O(n \log n)$).

4.2. Algoritmos de Búsqueda

La búsqueda es el proceso de encontrar la ubicación de un elemento dentro de una colección.

• Búsqueda Lineal (Linear Search): Recorre la colección elemento por elemento hasta encontrar el valor deseado. Funciona en cualquier array, pero es lento ($O(n)$).
• Búsqueda Binaria (Binary Search): Requiere que la colección esté ordenada. Divide repetidamente a la mitad el intervalo de búsqueda. Es extremadamente rápida ($O(\log n)$).

Este tema explora en profundidad cómo Git y GitHub han revolucionado la gestión de proyectos, desde los conceptos fundamentales hasta los comandos esenciales para optimizar tu flujo de trabajo.

1. Fundamentos: Git y Conceptos Clave

1.1. ¿Qué es Git?

Git es un software de control de versiones distribuido (DVCS), creado por Linus Torvalds en 2005. A diferencia de los sistemas centralizados, Git proporciona a cada desarrollador una copia local completa del historial de desarrollo del proyecto. Esta naturaleza distribuida fomenta el desarrollo no lineal y agiliza la gestión de ramas y la fusión de diferentes versiones del código.

1.2. El Ciclo de Vida y los Estados de un Archivo

El flujo de trabajo básico en Git sigue una secuencia lógica de tres etapas:

1. Modificar: Se realizan cambios en el Directorio de Trabajo (la copia de los archivos en tu máquina local).
2. Preparar (Staged): Los archivos modificados se añaden al Área de Preparación (Staging Area o Index), que es la zona intermedia donde se seleccionan los cambios que se incluirán en el próximo commit.
3. Confirmar (Committed): Se realiza un commit, que almacena la instantánea de los archivos preparados de forma permanente en el Repositorio Local.

| Concepto Clave | Descripción | | :

En este tema, exploraremos la estructura detrás de cada acción web, desde el Modelo Cliente-Servidor hasta las arquitecturas modernas, pasando por los componentes clave como el Protocolo HTTP y las APIs que hacen posible el desarrollo web contemporáneo.

1. Componentes Clave y Roles en el Desarrollo Web

El desarrollo web se divide conceptualmente para gestionar la complejidad de la interacción entre el usuario y el servidor.

• Front-end (Lado del Cliente): Es la parte visible y con la que el usuario interactúa directamente. Se construye con HTML, CSS y JavaScript, y su ejecución ocurre en el navegador del usuario.
• Back-end (Lado del Servidor): Es el cerebro de la aplicación, responsable de la lógica de negocio, la interacción con bases de datos y la generación de contenido dinámico. Tecnologías como PHP, Java, Python o C# se usan aquí.

La tendencia moderna es que el Back-end sea agnóstico o universal, exponiendo su funcionalidad a través de APIs (Application Programming Interfaces) que pueden ser consumidas por cualquier cliente, ya sea web, móvil o de escritorio.

En esta segunda unidad del módulo, exploraremos qué define un IDE, cuáles son sus componentes esenciales y te guiaremos en la instalación y configuración de las herramientas que utilizaremos en el curso: IntelliJ IDEA, JetBrains Rider y Visual Studio Code (VS Code).

1. ¿Qué es un IDE?

Un IDE no es solo un editor; es una suite integrada de herramientas. Entender sus componentes te permite aprovechar al máximo sus capacidades:

• Editor de Código Fuente: Herramienta principal con Resaltado de Sintaxis y Autocompletado de Código (o IntelliSense en VS Code).
• Compilador/Intérprete: Se encarga de traducir el código fuente a código legible para la máquina, permitiendo la ejecución directa.
• Depurador (Debugger): Esencial para probar y corregir errores. Permite detener la ejecución con puntos de ruptura (Breakpoints) y examinar el estado de las variables.
• Control de Versiones: Integración nativa con sistemas como Git para gestionar los cambios del código a lo largo de la construcción de la aplicación.
• Terminal Integrada y Plugins: La terminal ofrece acceso a herramientas externas, mientras que los plugins extienden la funcionalidad del IDE, brindando la modularidad necesaria.

2. Preparación del Entorno: Herramientas Clave

Para el curso, configuraremos una estación de trabajo robusta con las siguientes herramientas:

Entornos de Desarrollo (IDE)

• JetBrains (IntelliJ IDEA y Rider): Ambos comparten la misma filosofía de uniformidad en su flujo de trabajo y la gestión de Tool Windows. Se recomienda la instalación a través de la Toolbox App de JetBrains para gestionar fácilmente actualizaciones y diferentes versiones.
• Visual Studio Code (VS Code): Un editor/IDE ligero, organizado en torno a un workspace y altamente personalizable mediante extensiones. Su herramienta de navegación central es la Paleta de Comandos (Ctrl+Shift+P).

Plataformas de Desarrollo (SDK)

Instalar los Kits de Desarrollo es un paso fundamental, ya que son la base para que el IDE pueda compilar y ejecutar el código:

• JDK 21 (Java Development Kit).
• .NET 8 (SDK/Runtime).

Herramientas de Apoyo

• Git y GitKraken: Git es esencial para el Control de Versiones, y GitKraken lo complementa con una interfaz visual intuitiva.
• Personalización Visual: Se recomienda la instalación de fuentes como Fira Code o JetBrains Mono y la herramienta Oh My Posh para personalizar la terminal y mejorar la experiencia de codificación.

Enlaces de interés:

Vídeo resumen del tema

Podcast del tema

Link al repositorio del módulo: https://github.com/joseluisgs/EntornosDesarrollo-02-2025-2026

El problema fundamental es que cada entorno es un mundo, con diferentes versiones de software, librerías y configuraciones de red, lo que hace que las aplicaciones sean impredecibles. Los contenedores de Docker solucionan esto al empaquetar una aplicación con todo lo que necesita para funcionar en una unidad aislada y estandarizada.

Contenidos clave de la unidad

En esta unidad, aprenderás los conceptos esenciales de Docker y cómo aplicarlos en el desarrollo y despliegue de aplicaciones, incluyendo:

Diferencia entre contenedores y máquinas virtuales (VM): Los contenedores son mucho más ligeros y eficientes porque comparten el kernel del sistema operativo del anfitrión, mientras que una VM simula un ordenador completo y es más pesada.

Componentes principales de Docker: Descubrirás los dos pilares fundamentales:

• Imágenes: La plantilla o la receta inmutable que contiene todo lo necesario para la aplicación.
• Contenedores: La instancia viva y en ejecución de una imagen, donde reside y funciona la aplicación.
• Comandos básicos de Docker CLI: Conocerás los comandos esenciales para gestionar el ciclo de vida de los contenedores, como docker run para poner en marcha un contenedor, docker ps para ver los activos, docker pull para descargar imágenes y docker stop y docker rm para detenerlos y borrarlos.
• Creación de imágenes con Dockerfile: Aprenderás a crear tus propias imágenes personalizadas de forma reproducible y transparente. El Dockerfile es un simple archivo de texto con una lista de instrucciones paso a paso para construir la imagen.
• Orquestación con Docker Compose: Verás cómo Docker Compose simplifica el despliegue de aplicaciones multicontenedor (como un servidor web y una base de datos) usando un único archivo de configuración (docker-compose.yml) y un solo comando.

Esta forma de trabajar no solo proporciona portabilidad, consistencia y eficiencia, sino que también promueve la reproducibilidad, eliminando el problema de que "solo funciona en mi máquina".

Enlaces de interés:

Vídeo resumen del tema

Podcast del tema

Link al repositorio del módulo: https://github.com/joseluisgs/DespliegueAplicacionesWeb-02-2025-2026

La programación estructurada busca crear programas más limpios y legibles mediante el uso de tres estructuras de control básicas: secuencia, selección (condicionales) e iteración (bucles). Por su parte, la programación modular se basa en la técnica "Divide y Vencerás" para dividir un programa grande en partes más pequeñas y manejables, llamadas módulos, que resuelven problemas específicos.

Contenidos clave de la unidad

En este tema, aprenderás los siguientes conceptos esenciales:

1. Programación Estructurada: Conocerás los tres tipos de estructuras de control que forman la base de la programación:

• Secuencias: Las instrucciones se ejecutan una tras otra en el orden en que están escritas.
• Condicionales: Se usan para tomar decisiones y ejecutar código de forma selectiva (if, if-else, switch).
• Bucles: Permiten repetir un bloque de código. Se abordan bucles definidos (for) e indefinidos (while, do-while), así como mecanismos de control como las banderas (flags) y los centinelas.

2. Programación Modular: Aprenderás a dividir el código en módulos reutilizables para facilitar la organización y la colaboración. Los módulos se implementan como funciones (que devuelven un valor) y procedimientos (que no devuelven nada).

• Paso de parámetros: Entenderás la diferencia clave entre el paso por valor (se pasa una copia del dato) y el paso por referencia (se pasa la dirección de memoria de la variable original con la palabra clave ref).
• Ámbito de las variables: Descubrirás dónde pueden ser accesibles las variables, distinguiendo entre el ámbito global y el local.
• Técnicas avanzadas: Se exploran otros conceptos como los parámetros por defecto, la sobrecarga de funciones, el uso de parámetros variables (params) y la recursividad, una técnica en la que una función se llama a sí misma.

3. Control de Excepciones: Verás cómo utilizar los bloques try, catch y finally para manejar errores inesperados de forma controlada. También se incluye el uso de la sentencia throw para lanzar excepciones de forma manual y las aserciones (assert) para depurar el código.

Enlaces de interés:

Vídeo resumen del tema

Podcast del tema

Link al repositorio del módulo: https://github.com/joseluisgs/Programacion-02-2025-2026

UD1 - Desarrollo, control de versiones y documentación

El tema destaca que el control de versiones es un sistema esencial que registra los cambios en un proyecto a lo largo del tiempo, permitiendo a los desarrolladores rastrear la evolución del software, revertir errores y coordinar el trabajo en equipo de manera eficiente.

Puntos clave de la unidad:

• Git y GitHub: La unidad explora en profundidad el uso de Git, un software de control de versiones distribuido, y GitHub, una plataforma que facilita la colaboración.
• Conceptos esenciales de Git: Se explican conceptos cruciales como repositorio, commit, rama, área de preparación y el directorio de trabajo.
• Comandos de Git: El documento detalla los comandos esenciales para la configuración inicial, creación de repositorios, gestión de cambios (add, commit, status), historial de revisiones (log, show), deshacer cambios (revert, reset), ramificación y fusión (branch, checkout, merge, rebase), ignorar archivos (.gitignore) y el trabajo con repositorios remotos (push, pull, fetch).
• Colaboración con GitHub: Se cubren las herramientas clave de colaboración de GitHub, como las Pull Requests, que son esenciales para la revisión de código, y los Forks, que permiten a los desarrolladores contribuir a proyectos de código abierto.
• Flujos de trabajo: Se presentan dos de los flujos de trabajo más comunes: GitHub Flow, un modelo simple y ágil, y GitFlow, una metodología más estructurada para proyectos complejos.
• Documentación de Código: El segundo pilar de la unidad es la documentación. El documento explica cómo usar Markdown para la documentación general, y cómo generar documentación técnica directamente desde el código usando herramientas como Javadoc para Java y XMLdoc para C#.

Este tema es crucial para que los estudiantes adquieran las herramientas necesarias para trabajar en un entorno profesional, asegurando que el código no solo sea funcional, sino también colaborativo y bien documentado.

Tienes un vídeo introductorio del tema en el siguiente enlace:

El podcast del tema en el siguiente enlace:

Puedes encontrar todos los materiales y ejemplos de código relacionados con esta unidad en el siguiente repositorio de GitHub:

Link al repositorio del módulo: https://github.com/joseluisgs/DespliegueAplicacionesWeb-01-2025-2026

UD1 - Introducción a la Programación de Software en Servidor

En esta unidad, se abordan varios temas clave que son esenciales para comprender cómo funcionan las aplicaciones web desde el lado del servidor y cómo se integran con el front-end.

Puntos Clave de la Unidad:

• Modelos de Ejecución: La unidad diferencia entre el código que se ejecuta en el lado del cliente (Front-end, con tecnologías como HTML, CSS y JavaScript) y el que se ejecuta en el lado del servidor (Back-end, con lenguajes como PHP, Java o Python).
• Front-end y Back-end: El documento resalta la división de roles entre el desarrollador front-end, enfocado en la interfaz de usuario, y el desarrollador back-end, centrado en la lógica de negocio y la interacción con bases de datos. Además, se explica cómo el back-end se ha vuelto "agnóstico", exponiendo su funcionalidad a través de APIs que pueden ser consumidas por cualquier tipo de cliente, como aplicaciones web o móviles.
• Arquitecturas Web: Se exploran diferentes modelos arquitectónicos, como la Arquitectura Cliente-Servidor y la evolución de la web (de la Web 1.0 a la 3.0). Se describen arquitecturas de software como la monolítica, la de capas, los microservicios (con el ejemplo de Netflix) y la serverless, comparando sus características en una tabla. También se presenta el patrón Modelo-Vista-Controlador (MVC), que es un pilar en el desarrollo web del lado del servidor.
• Protocolos y Servicios: La unidad detalla el funcionamiento del protocolo HTTP y HTTPS, incluyendo sus métodos (GET, POST, etc.) y códigos de estado. También se aborda el concepto de Servicio Web y la comunicación a través de APIs.
• Despliegue y Seguridad: Finalmente, se introduce el concepto de despliegue de una aplicación web, sus objetivos (accesibilidad, estabilidad, escalabilidad y seguridad), y las tecnologías asociadas, como los contenedores (Docker), la computación en la nube y la Integración Continua / Despliegue Continuo (CI/CD).

Este tema es crucial para entender el funcionamiento de cualquier aplicación web moderna y los diferentes roles y tecnologías que se utilizan en su creación y mantenimiento.

Puedes ver un vídeo resumen del tema en el siguiente enlace y consultar el código de ejemplo en el repositorio de GitHub:

El podcast del tema en el siguiente enlace:

Link al repositorio del módulo: https://github.com/joseluisgs/DesarrolloWebEntornosServidor-01-2025-2026

UD1: Desarrollo de Software: Los pilares de la programación profesional

Antes de sumergirnos en las herramientas y técnicas, es esencial entender el proceso completo que hay detrás de la creación de una aplicación. La Unidad Didáctica 1: Desarrollo de Software nos proporciona esa base sólida. Aquí no solo se aprende a escribir código, sino a entender todo el ciclo de vida de una aplicación, desde la idea inicial hasta su retirada del mercado.

El desarrollo de software es un proceso complejo y estructurado. Abarca la disciplina de planificar, diseñar, construir y mantener sistemas, lo que garantiza que los programas sean eficientes, seguros y que satisfagan las necesidades del usuario final.

El ciclo de vida del software: Un viaje en 8 fases

Comprender el ciclo de vida del software es crucial. Es la hoja de ruta que nos guía en cada proyecto, y sus fases son un estándar en la industria.

1. Planificación: Aquí se define el qué y el porqué del proyecto, estableciendo objetivos, alcance y viabilidad.
2. Análisis: En esta fase se recopilan los requisitos funcionales y no funcionales del cliente. El resultado es el documento de Especificación de Requisitos del Software (ERS), un contrato entre cliente y desarrollador.
3. Diseño: Una vez que sabemos lo que hay que hacer, esta fase define el cómo. Se descompone el sistema en módulos y se toman decisiones sobre la arquitectura, la base de datos y el lenguaje de programación.
4. Codificación: La fase donde el diseño se transforma en código fuente en un lenguaje de programación. Es la tarea del programador y debe ser modular, legible y eficiente.
5. Pruebas: El objetivo es encontrar y corregir defectos. Incluye pruebas unitarias, de integración, funcionales y estructurales.
6. Documentación: Fundamental para el mantenimiento y la reutilización del software. Se crean guías técnicas, manuales de usuario y de instalación.
7. Explotación (Despliegue): Se instala y configura la aplicación en el entorno final del cliente para que pueda empezar a usarla.
8. Mantenimiento: La fase más larga, donde el software se adapta, corrige y mejora a lo largo del tiempo.

Metodologías: De lo clásico a lo ágil

El tema destaca la evolución de las metodologías de desarrollo. Aunque los modelos clásicos como el de cascada o el modelo en V son secuenciales y rígidos, el curso se enfoca en las metodologías ágiles, más modernas y flexibles. Estas se basan en el Manifiesto Ágil, que prioriza la colaboración con el cliente y la adaptación al cambio sobre la rigidez de un plan.

Además, se estudian enfoques como Scrum, que usa iteraciones cortas llamadas sprints para entregar valor de forma continua, y Kanban, que gestiona el flujo de trabajo de forma visual y orientada a la demanda.

Lenguajes, traductores y herramientas

El tema también profundiza en conceptos clave como los lenguajes de programación (desde los de bajo nivel como el ensamblador, hasta los de alto nivel como Java o Python), el proceso de traducción de código (compilación, interpretación y modelos mixtos), y el papel de las máquinas virtuales y los frameworks para la portabilidad y el desarrollo rápido de aplicaciones.

Finalmente, se presentan las herramientas de apoyo, como los IDE (Entornos de Desarrollo Integrado), que agrupan todas las utilidades para aumentar la productividad.

Puedes ver el vídeo introductorio del tema en el siguiente enlace y consultar el código de ejemplo en el repositorio de GitHub:

El podcast del tema en el siguiente enlace:

Link al repositorio del módulo: https://github.com/joseluisgs/EntornosDesarrollo-01-2025-2026

UD1 - Introducción a la Programación Software

Fundamentos de la Programación y Algoritmos La unidad comienza definiendo qué es programar: el proceso de crear software, que abarca desde la concepción de una idea hasta su implementación. Un elemento central es el algoritmo, una serie de pasos claros y ordenados para resolver un problema de forma genérica e independiente de cualquier lenguaje. Se exploran las características esenciales de los algoritmos, como ser finitos, precisos y definidos, y se resalta la diferencia fundamental entre un algoritmo (la idea) y un programa (la implementación en un lenguaje específico).

Lenguajes y Paradigmas de Programación La segunda parte del resumen se enfoca en los lenguajes de programación. Se detallan conceptos fundamentales de un lenguaje (léxico, sintaxis y semántica) y se hace un recorrido por los principales paradigmas de programación, como la programación imperativa, orientada a objetos (POO), declarativa y funcional. El documento también clasifica los lenguajes según su nivel de abstracción (bajo, medio y alto nivel), su mecanismo de traducción (compilados, interpretados y mixtos) y su sistema de tipado (fuerte, débil, estático y dinámico).

Elementos Fundamentales Finalmente, la unidad introduce los elementos básicos de cualquier programa, como la estructura (Main()), las reglas de sintaxis, los tipos de datos (int, decimal, string, bool), las variables, las constantes y los literales. Estos conceptos son cruciales para empezar a escribir código de forma estructurada y legible.

Puedes ver un resumen en vídeo de este tema en el canal del profesor y encontrar todo el material en su repositorio de GitHub:

El podcast del tema en el siguiente enlace:

Link al repositorio del módulo: https://github.com/joseluisgs/Programacion-01-2025-2026

El objetivo central de este módulo es formarnos en las competencias necesarias para implantar, gestionar y mantener aplicaciones web en entornos de producción. No solo se trata de que una aplicación funcione en nuestro ordenador, sino de asegurar su funcionamiento en servidores reales, con la fiabilidad y seguridad que el mercado exige.

Una ruta didáctica inspirada en el ciclo de vida profesional

La programación de este módulo está diseñada para simular un flujo de trabajo profesional, priorizando el aprendizaje de herramientas y metodologías que son estándar en la industria. El temario va de lo general a lo específico, comenzando con las prácticas más relevantes antes de profundizar en los detalles técnicos del despliegue.

Aquí tienes un vistazo a las unidades didácticas que componen el curso:

• UD1: Introducción a la virtualización: Se sientan las bases de tecnologías como Docker y la virtualización de servidores en la nube y contenedores, fundamentales para crear entornos de trabajo aislados y replicables.
• UD2: Control de versiones y documentación: Se aborda el uso de Git y GitHub, herramientas colaborativas que nos permiten gestionar la evolución del código y mantener una documentación precisa y accesible.
• UD3: Arquitectura Web y Fundamentos del Despliegue: Una unidad teórica-práctica para comprender las bases de las arquitecturas web y los protocolos sobre los que se sustenta el funcionamiento de un servidor.
• UD4: Despliegue de Páginas y Aplicaciones Web: Es el corazón del módulo. Aquí se aprende a instalar y configurar servidores web y de aplicaciones, creando sitios virtuales y asegurando las comunicaciones con certificados digitales.
• UD5: Despliegue de Sistema de Transferencia de Ficheros: Se profundiza en la administración de servidores de archivos, aprendiendo a garantizar la disponibilidad y seguridad del servicio.
• UD6: Verificación y Validación: Esta unidad subraya la importancia de las pruebas. Se analizan los servicios de red implicados en la ejecución de las aplicaciones, como los sistemas de nombres jerárquicos y los servicios de directorio.
• UD7: Integración y Despliegue Continuo (CI/CD): El broche de oro. Se aprende a automatizar los flujos de trabajo con herramientas de integración continua, un proceso que representa el estándar de la industria DevOps.

La metodología: Construyendo conocimiento de forma iterativa

El curso se apoya en el Aprendizaje Basado en Retos y Proyectos, donde resolveremos problemas reales del sector donde se promueve una metodología de aprendizaje iterativo e incremental. Esto significa que los conocimientos se refuerzan continuamente y cada unidad se construye sobre la base de la anterior, garantizando una comprensión profunda y aplicable.

Como puedes ver en el vídeo a continuación, la metodología se centra en que el alumno sea el protagonista de su propio aprendizaje, investigando y resolviendo desafíos prácticos.

El módulo no es un bloque aislado, sino que actúa como un puente que conecta el desarrollo con la puesta en producción, proporcionando las herramientas de operación y calidad necesarias para llevar las aplicaciones a un estado productivo, fiable y seguro. Los proyectos que se desarrollen en los módulos de Desarrollo Web en Entorno Servidor y Cliente, por ejemplo, se gestionarán y desplegarán utilizando las competencias adquiridas aquí.

Para que no te pierdas ni un solo detalle, todos los materiales y el código de ejemplo estarán disponibles en el siguiente repositorio de GitHub, el cual será nuestro manual de referencia durante todo el curso.

Link al repositorio del módulo: GitHub - Despliegue de Aplicaciones Web DAW 2025-2026

Unidades Didácticas: El camino hacia la maestría del servidor

La programación didáctica de este módulo está diseñada para un aprendizaje progresivo y coherente. A continuación, se detallan las unidades que nos guiarán a través de las complejidades del desarrollo en el servidor:

• UD1: Introducción al desarrollo de software en Servidor: Se establecen los fundamentos teóricos, como los modelos de ejecución de código en el servidor y el cliente, y se introducen las tecnologías y los frameworks más relevantes para la programación web en este entorno.
• UD2: Desarrollo de servicios web en JVM: Se profundiza en las tecnologías que permiten el acceso a bases de datos y en la creación de servicios web reutilizables. Se aprende a programar y verificar la funcionalidad de los servicios, a consumirlos y a documentarlos adecuadamente.
• UD3: Desarrollo de páginas web dinámicas en JVM: En esta unidad, se aprende a incrustar código en lenguajes de marcas para crear páginas dinámicas. Se enseñan las estructuras de programación, el manejo de formularios, el mantenimiento del estado de las aplicaciones y la separación de la lógica de negocio y la presentación.
• UD4: Desarrollo de servicios web en .NET: Similar a la UD2, esta unidad aplica los mismos conceptos de bases de datos y servicios web, pero utilizando el entorno y las tecnologías de .NET.
• UD5: Desarrollo de páginas web dinámicas en .NET: De forma análoga a la UD3, esta unidad se centra en la generación de páginas web dinámicas en el entorno de .NET, incluyendo la validación de formularios y la modificación dinámica de contenidos.

Una metodología práctica y orientada a la industria

La metodología del curso se apoya en el Aprendizaje Basado en Retos y Proyectos, con un enfoque en la resolución de problemas reales. En lugar de un libro de texto, se utilizarán recursos digitales gratuitos como vídeotutoriales y documentación técnica. Esto nos acostumbra a buscar información de forma autónoma, una habilidad vital en el mundo profesional.

El módulo está diseñado para construir el conocimiento de forma iterativa, permitiendo que las habilidades se consoliden y refuercen continuamente. El módulo establece una transversalidad vertical y horizontal con otras asignaturas del ciclo, por lo que los proyectos que se desarrollen aquí se integrarán con los de otros módulos como Desarrollo Web en Entorno Cliente y Despliegue de Aplicaciones Web.

Aquí puedes ver el vídeo introductorio del módulo:

Todos los materiales del curso, incluyendo los apuntes y proyectos, se encuentran disponibles en el siguiente repositorio de GitHub, que sirve como un recurso central para el aprendizaje y la colaboración:

Link al repositorio del módulo: GitHub - Desarrollo Web en Entorno Servidor DAW 2025-2026

El objetivo principal de este módulo es dotarte de los conocimientos y las destrezas necesarias para que puedas enfrentarte al desarrollo de aplicaciones de principio a fin, desde la planificación hasta la puesta en marcha. Se hace un gran hincapié en el diseño orientado a objetos, las mejores prácticas en pruebas de software, y el uso de sistemas de control de versiones.

Unidades didácticas

El temario de este módulo está estructurado de manera progresiva, garantizando que cada concepto construya sobre el anterior.

• UD1: Desarrollo de Software: Una introducción a los cimientos teóricos. Aquí se definen los conceptos de programa informático y se analizan las fases del ciclo de desarrollo de una aplicación, incluyendo las metodologías ágiles.

• UD2: Entornos de Desarrollo de Software: Aprenderás a dominar los IDEs (Entornos de Desarrollo Integrados). Esto no es solo instalar, sino también personalizar, automatizar y usar estas herramientas para generar ejecutables.

• UD3: Sistemas de Control de Versiones: Fundamental para el trabajo en equipo. Se profundiza en el uso de Git y GitHub, los estándares de la industria para el desarrollo colaborativo y el control del código a lo largo del tiempo.

• UD4: Diseño Orientado a Objetos: Diagrama de Clases: La planificación es clave. Utilizarás herramientas específicas para diseñar la arquitectura de tus proyectos, creando diagramas de clases y generando código a partir de ellos (y viceversa).

• UD5: Diseño Orientado a Objetos: Diagramas de Comportamiento: Complementando al anterior, aprenderás a modelar el comportamiento de las aplicaciones a través de diagramas de casos de uso, interacción, actividades y estados.

• UD6: Optimización y Refactorización: Esta unidad se centra en mejorar la calidad y la eficiencia del código sin alterar su funcionalidad. Se abordarán patrones de refactorización y el uso de analizadores de código.

• UD7: Diseño y Realización de Pruebas: La validación es esencial. Aprenderás a definir casos de prueba, usar herramientas de depuración y a implementar pruebas automáticas para garantizar la fiabilidad de tu software.

Un enfoque práctico y conectado con la industria

La metodología del curso se basa en el Aprendizaje Basado en Retos y Proyectos y el concepto de Aula Invertida. Esto significa que, en lugar de clases magistrales, te enfrentarás a problemas reales del sector, utilizando tutoriales y documentación para resolverlos, mientras el tiempo en clase se dedica a la práctica y la colaboración.

Aquí puedes ver el vídeo introductorio al módulo:

Link al repositorio del módulo: GitHub - Entornos de Desarrollo DAW 2025-2026

Un temario moderno y práctico

Olvídate de los temarios anticuados. Nuestro plan de estudios se ha actualizado para que domines los conceptos más relevantes en el mundo del desarrollo de software. Aprenderemos a manejar las herramientas y tecnologías que realmente se usan en las empresas, y no solo teoría.

El viaje a través del temario: Las 10 unidades clave

El temario de este módulo está diseñado como un camino evolutivo, comenzando por los fundamentos y avanzando hacia la creación de software complejo y moderno. Las unidades se han secuenciado de forma lógica para que asimiles cada concepto antes de pasar al siguiente.

A continuación, te damos más detalles sobre lo que verás en cada una de ellas:

• UD1: Introducción a la programación de software: En esta unidad se sientan las bases de todo el curso. Aprenderás qué es un programa, los conceptos de algoritmos, y los elementos fundamentales como variables, constantes y operadores. Es el punto de partida para que te familiarices con la sintaxis y la estructura de un programa.

• UD2: Programación estructurada y modular: Aquí te sumergirás en la lógica de programación. Trabajarás con estructuras de control como if-else y for. Además, aprenderás a escribir y depurar código, a manejar excepciones y a crear funciones, lo que te permitirá empezar a organizar tus programas de forma más eficiente.

• UD3: Aplicación de las estructuras de almacenamiento: Esta unidad se enfoca en cómo manipular y almacenar datos. Verás la gestión de matrices (arrays) y la manipulación de cadenas de texto. Aprenderás sobre expresiones regulares, muy útiles para buscar patrones en textos. También tendrás una primera toma de contacto con algoritmos básicos de ordenación y búsqueda.

• UD4: Programación Orientada a Objetos: El corazón del curso. Conocerás los conceptos de objeto, clase, métodos y propiedades. Aprenderás a crear tus propias clases y a instanciar objetos, entendiendo los principios de la programación orientada a objetos (POO) y cómo utilizar librerías externas.

• UD5: Programación Avanzada Orientada a Objetos: Una vez dominada la base de la POO, esta unidad te lleva al siguiente nivel. Profundizarás en conceptos como la herencia, las interfaces y la composición. Aprenderás a diseñar jerarquías de clases y a aplicar principios avanzados que te permitirán crear software más escalable y robusto.

• UD6: Programación funcional, Genérica y Colecciones: Un tema muy moderno y demandado. En esta unidad, trabajarás con colecciones de datos, como las listas, y utilizarás iteradores para procesar información.

• UD7: Lectura y escritura de información externa. Ficheros: En esta unidad aprenderás a interactuar con el exterior. Verás cómo leer y escribir información en ficheros, manejar diferentes formatos de intercambio de datos como CSV, JSON y XML.

• UD8: Operaciones con Bases de Datos de Objetos y Colecciones: Te introducirás en el mundo de las bases de datos. Aprenderás las características de las bases de datos orientadas a objetos, cómo instalarlas y a programar aplicaciones para almacenar, recuperar, actualizar y eliminar información.

• UD9: Gestión de Bases de Datos Relacionales: Una unidad esencial para cualquier desarrollador. Aquí te centrarás en las bases de datos relacionales, la forma más común de gestionar información en el mundo laboral. Programarás conexiones, escribirás código para almacenar y recuperar datos, y gestionarás información de manera eficiente.

• UD10: Programación Interactiva e Interfaces Gráficas: Para cerrar el ciclo, esta unidad te enseña a crear interfaces de usuario sencillas. Aprenderás a programar controladores de eventos y a escribir programas que usen una interfaz gráfica para la entrada y salida de información, dándole a tus proyectos una cara visible para los usuarios.

La metodología: Aprender haciendo La clave de este módulo es la metodología de aprendizaje. No nos quedaremos en la teoría. La mayoría de las clases se centrarán en la resolución de retos y casos prácticos, que son la mejor forma de consolidar conocimientos. Como verás en el vídeo a continuación, el profesor nos animará a preguntar y a trabajar en grupo para resolver problemas, fomentando un ambiente de colaboración y apoyo mutuo.

Tu compañero de viaje: El repositorio de GitHub Para que no pierdas el hilo de lo que se hace en clase, todos los materiales y ejemplos de código estarán disponibles en un repositorio de GitHub. Esto no solo facilita el acceso, sino que también nos introduce en el uso de una herramienta fundamental para cualquier desarrollador. Podrás consultar el código, ver los cambios y, lo que es mejor, contribuir y hacer tus propios proyectos.

Link al repositorio del módulo: GitHub - Programación DAW 2025-2026

Te dejo el enlace a su vídeo en YouTube y te invito a que te suscribas a su canal y a su pódcast. El equipo de Algoritmo Salvaje es un equipo de profesionales que se dedican a llevarte al siguiente nivel en el mundo del desarrollo y compartir su experiencia con todos nosotros. Sobre todo, si eres alumno de DAW o DAM, te puede interesar su contenido. Te invito a que te suscribas y disfrutes del resto de los pódcast que vendrán en su canal.

Cambiar de turno a veces no es tan fácil como uno imagina. En mi caso ha venido unido a multitud de cambios y ajustes que han hecho el proceso un poco más complicado de lo habitual.

Se dice que es bueno cambiar de costumbres en el entorno laboral cada dos años. En el fondo, ir al turno de tarde ha tenido ese efecto. Aunque sea el mismo centro, implica conocer nuevas personas, adaptarse a nuevos horarios y cambiar determinados hábitos docentes. Por supuesto, ha implicado preparar un nuevo módulo: Desarrollo Web en Entornos Servidor. En este aspecto, he querido centrarme en varias tecnologías revisitando los contenidos del currículo con ellas y agrupándolas en varios grupos: JVM (y SpringBoot), Node.js (y Nest.js) y finalmente PHP (y Laravel). Esperemos que el experimento salga bien. En el fondo, es un buen aliciente y una buena responsabilidad que me ha gustado.

El turno de tarde es más tranquilo y agradable. A veces es como si no estuvieses en el mismo centro. Agradezco a todos mis compañeros/as que me hayan ayudado al cambio.

Pero este cambio ha supuesto cambiar muchas cosas en mi día a día. Y aunque no lo parezca, una de las cosas que más me han costado es el cambio de los entrenamientos de tenis. Esto hace que ahora tenga que ir por las mañanas y me ha costado ajustar todo. Quizás porque me gustaba ir por la tarde cuando ya "todas las obligaciones docentes estaban hechas". Ahora vas con la cabeza pensando en lo que debes hacer esa tarde. Esto para mí es duro y a veces no lo disfruto, porque entre "bola y bola" tengo una petición REST en la cabeza por resolver o explicar para que entiendan el poder de los JWT. De hecho, la broma de los "cambios de biorritmos" salió de mi entrenador del CT Alborada, Miguel Ángel, y le doy las gracias por ello. Primero por su ayuda en todo el proceso, y luego por darme la excusa perfecta de mi lamentable estado algunos días.

Además, se ha juntado el tema de la guitarra. Ha habido muchos cambios, debido a mi nuevo luthier, el genial y fantástico Juan Brieva. Él ha puesto al día y me ha ayudado a mejorar mis guitarras. Esto ha llevado un tiempo, y luego hay que volver a educar mi oído a tantos cambios. No siempre ha salido todo a la primera, y seguimos luchando con ello. Además, estos cambios implican mover algunos componentes, vender pedales, ajustar set-up. Seguimos en ello. Creo que eso es algo que no acaba nunca.

Si seguimos con la guitarra, he iniciado el proceso de buscar otra persona que me ayude a avanzar un poco. Mi profesor desaparece más que el Guadiana con sus nuevas obligaciones en Shanghái. Yo pensaba que el nuevo horario nos daría la libertad de avanzar más (diferencias horarias), pero no ha sido así. Así que en eso andamos. Otra cosa que está minando un poco de energía diaria.

El cambio horario ha implicado que ya determinadas personas no cuenten conmigo a nivel formativo. Pero esto es algo normal y aunque, como bien se dice, "los negocios son negocios", aprendes de ello para futuras ocasiones. En este tiempo sé que se siguen usando mis materiales y para eso están.

Estos meses también me han dejado desengañado con determinados aspectos de la comunidad de internet del desarrollo. Quizás a veces es bueno desconectar y alejarse de todo un poco para comprender mejor las cosas. Podría decir que hay tantos refritos y saturación que cansa tener que explicar determinados puntos de vista y que algunos sectores están cada vez más radicalizados.

Finalmente, si no fueran suficientes tantos cambios, he tenido que comprar un nuevo portátil. Lo siento mucho, pero para mí es imposible dar clase en los ordenadores congelados, donde día sí, día también me tengo que traer el código, probar librerías, ajustar los dockers, etc. Somos el único gremio que debe poner su propio material para dar clase. Espero que esto cambie. El año pasado, al menos, tenía un portátil del departamento; este año no. Quizás porque este año ni lo he pedido. En cualquier caso, tenía uno, pero no daba la talla con IntelliJ y otro software corriendo a la vez.

No quiero olvidarme de mi "gran vecino o empresa de limpieza" que me ha rayado el coche, otro cambio más.

En fin, muchos cambios y ajustes que espero que merezcan la pena.

Te dejo el enlace a su vídeo en YouTube y te invito a que te suscribas a su canal y a su pódcast. Antonio es uno de los profesionales y personas que más respeto, no solo por su excelente contenido, sino por su labor diaria en la generación de contenido de calidad. El equipo de DevExpert.io es un equipo de profesionales que se dedican a llevarte al siguiente nivel en el mundo del desarrollo con una calidad increíble. Aparte de que me une una especial amistad con Antonio, lo que hizo que el rato que pasamos fuera de lo más ameno. Te invito a que te suscribas y disfrutes del resto de los pódcast que vendrán en su canal.

Este curso 2023/2024 ha comenzado con muchos cambios en el departamento, y además a nivel personal. En el departamento de Informática del IES Luis Vives ha habido cambios en la dirección del departamento. Además, se han producido cambios en la plantilla de profesorado, y con ello, cambios en la distribución de la docencia.

Por mi parte, el curso pasado en el centro no fue uno de los mejores por distintos aspectos. A veces, los cursos son como cosechas: por mucho que te esfuerces, puede que venga una granizada y eche parte de tu trabajo por tierra. Además, sabemos que la profesión de docente a veces no es muy valorada en estos tiempos y que el alumnado y otros factores externos no siempre ayudan. Pero no pasa nada, hay que seguir adelante.

Por otro lado, fue increíble poder estrechar lazos y colaborar con distintas personas que admiro o ayudar a compañeros/as en cursos de formación. Esto me hizo crecer como persona y como profesional y fue una experiencia muy enriquecedora.

Por los factores de cambios en el departamento y nuevos intereses vi la oportunidad de dar clases en DAW en turno de tarde y dejar DAM.

En estos momentos, estoy impartiendo en DAW:

• Programación 1.º DAW.
• Entornos de Desarrollo 1.º DAW.
• Desarrollo Web en Entorno Servidor 2.º DAW.

El turno de tarde ha implicado ajustar mi horario y mi vida personal, pero creo que ha sido una buena decisión. Pero como dice mi entrenador de tenis, el primer paso ha sido ajustar mis biorritmos a este nuevo horario. Esto ha implicado cambiar mis hábitos de sueño, alimentación y ejercicio. Aunque no lo creas, esto es muy importante para poder rendir al máximo en el trabajo y en la vida personal.

Por otro lado, este año estoy organizando una serie de charlas en un proyecto de "Laboratorio de Desarrollo de Software", donde personas de interés en el mundo del desarrollo vengan a compartir su experiencia con todo el alumnado y profesorado del centro. Por otro lado, el turno de tarde, al ser algo más tranquilo, me deja más tiempo para poder dedicarme a otros proyectos y a la investigación de nuevos aspectos, tecnologías para aplicarlas en el aula y fuera de ella.

Finalmente seguiré colaborando en formación del profesorado, amigos y otras entidades aportando mi granito de arena en la formación en el desarrollo del software. Esto sin duda se ha convertido en uno de mis pilares y me encanta poder compartirlo con otras personas.

Espero que este nuevo curso nos ayude a seguir aprendiendo, disfrutando y aportando al alumnado lo mejor de nosotros para que salga lo mejor preparado posible. ¡Vamos a por ello!

Te dejo el enlace a su vídeo en YouTube y te invito a que te suscribas a su canal y a su pódcast. Además, en su web puedes encontrar un montón de información interesante sobre tecnología y sobre el mundo de la informática y resolución de prácticas de DAM/DAW. Yo que tú no dejaría pasar la oportunidad de echarle un vistazo y estar al tanto de sus publicaciones.

Introducción

Una de las cosas esenciales que cualquier desarrollador de backend debe dominar es la creación de servicios REST.

En la actualidad, la gestión eficiente y efectiva de los recursos es una ventaja que debemos lograr. La programación reactiva nos ofrece soluciones para la demanda de tiempos de respuesta más rápidos y alta disponibilidad de los sistemas, características que se logran con modelos anteriores de microservicios, pero que dan soluciones a los problemas de uso excesivo de la CPU, bloqueo en operaciones de entrada y salida, o uso de memoria (debido a grandes grupos de subprocesos) de los que sufrían estos modelos.

A lo largo de esta serie de artículos, se presentan una serie de contenidos que aprenderás a través de las diferentes pistas de formación de Hyperskill. Con Hyperskill podrás profundizar en ellos, ampliarlos, analizar diferentes alternativas y convertirte en un verdadero desarrollador de backend.

En estos tutoriales mostramos cómo configurar una API REST reactiva utilizando Ktor y Kotlin, analizando todos los elementos, utilizando la programación orientada a ferrocarriles, la inyección de dependencias, las pruebas y aplicando varias configuraciones de seguridad, autenticación y autorización hasta que puedas implementarlo y disfrutar de tus logros. Recuerda que este código es pedagógico y muestra muchos de los contenidos que aprenderás en Hyperskill de una manera didáctica y fácil de leer. No tiene la intención de crear el mejor código de producción en entornos reales.

La Programación Reactiva

Siguiendo los principios del Manifiesto Reactivo, los sistemas reactivos deben ser:

• Responsivos: El sistema responde de manera oportuna siempre que sea posible.
• Resilientes: El sistema se mantiene responsivo ante fallos.
• Elásticos: El sistema se mantiene responsivo bajo cargas de trabajo variables.
• Basados en mensajes: Los sistemas reactivos se basan en el paso de mensajes asincrónico para establecer una frontera entre componentes que garantiza un acoplamiento laxo, aislamiento y transparencia de ubicación.

La programación reactiva se centra en trabajar con flujos asíncronos de fuentes de datos finitas o infinitas donde podemos observarlos.

La programación reactiva es un subconjunto de la programación asíncrona. Permite descomponer el problema en múltiples pasos discretos en los que cada uno se puede ejecutar de manera asíncrona y no bloqueante, para luego componerlos y producir el flujo de trabajo final.

La programación reactiva ofrece varias ventajas, incluida una mejor utilización de los recursos informáticos en sistemas multinúcleo y multiprocesador, y un rendimiento mejorado al reducir los puntos de serialización. Otro beneficio importante es el aumento de la productividad del desarrollador. Los paradigmas de programación tradicionales han tenido dificultades para proporcionar una forma sencilla y mantenible de manejar la computación asíncrona y no bloqueante y las operaciones de entrada y salida. La programación reactiva resuelve la mayoría de estos desafíos al eliminar la necesidad de coordinación explícita entre los componentes activos.

Para aprovechar la ejecución asíncrona, es necesario incluir el control de retroalimentación para evitar la sobreutilización o el consumo desmedido de recursos. Por ejemplo, en las entradas y salidas con bases de datos que utilizan JDBC, bloqueamos el hilo hasta que recibimos una respuesta. Este es un ejemplo sencillo de las cosas que vamos a resolver para mejorar la productividad de nuestros servicios.

Aquí es donde Ktor y Kotlin forman un equipo invencible. Ktor nos ofrece la posibilidad de crear servicios asíncronos (primera condición), y Kotlin ofrece corrutinas y Flows (flujos) para procesar colecciones de manera asíncrona y reactiva.

Creando un nuevo proyecto con Kotlin y Ktor

Kotlin es un lenguaje de programación de tipo estático que tiene varias ventajas sobre otros lenguajes de programación. Algunas de las ventajas de Kotlin son: interoperabilidad con Java, sintaxis concisa, seguridad ante valores nulos, soporte para programación funcional, funciones de extensión y coroutines, lo que facilita la escritura de código asíncrono y no bloqueante. Las coroutines son livianas y eficientes y se pueden utilizar para simplificar código asíncrono complejo. El soporte de Kotlin es una excelente elección para construir aplicaciones modernas.

Ktor es un framework ligero basado en Kotlin utilizado para crear aplicaciones y servicios web en el lado del servidor. Proporciona una API simple y flexible para construir aplicaciones asíncronas, basadas en eventos y no bloqueantes.

Con Ktor, los desarrolladores pueden crear fácilmente APIs RESTful, aplicaciones web y microservicios. Es un framework de código abierto que se puede utilizar para construir aplicaciones tanto web como móviles. Ktor se puede utilizar con coroutines y flows de Kotlin para escribir código asíncrono/reactivo de manera más concisa y legible.

Ktor utiliza plugins para ampliar su funcionalidad según las necesidades del proyecto. Algunos de ellos están incluidos por defecto, otros deben ser instalados. En ambos casos, debemos configurarlos para poder utilizarlos.

Podemos crear un proyecto Ktor desde el generador web: https://start.ktor.io/ (abrir el archivo zip) o desde el complemento IntelliJ IDEA.

En nuestro caso, como estamos experimentando con numerosos torneos de tenis, vamos a implementar una API REST reactiva para averiguar las raquetas más utilizadas en un torneo de tenis.

Primero debemos crear nuestro proyecto y agregar los siguientes plugins: enrutamiento y serialización de Kotlin. El primero nos permitirá crear las rutas o endpoints para gestionar las raquetas. El segundo nos ofrece la capacidad de intercambiar información en formato JSON.

Es posible que necesitemos otros plugins en el futuro, pero no importa, los agregaremos manualmente más adelante.

En "Ajustar configuración del proyecto", seleccionamos "configuración en archivo HOCON".

Analizando el código inicial

Tenemos la siguiente estructura:

Application: Contiene el código que inicia nuestro servicio y donde se indican los plugins a configurar. plugins/Routing: Define el enrutamiento de nuestra aplicación basado en... plugins/Serialization: Configura la serialización de nuestra aplicación basada en JSON. resources/application.conf: Configura la aplicación en función de las variables de entorno.

Configurar un Plugin

Puedes configurar un plugin utilizando funciones de extensión. Por ejemplo, "configureRouting" en Application.kt es una función de extensión que define el enrutamiento. Esta función se declara en un paquete de plugin separado (el archivo Routing.kt).

fun Application.configureRouting() {
   routing {
       get("/") {
           call.respondText("¡Hola Mundo!")
       }
   }
}

Ejecutar el Servicio

Puedes ejecutar el método principal y luego verificar tu API en http://0.0.0.0:8080. Verás el famoso mensaje: "¡Hola Mundo!"

Codificando nuestro servicio

Configurar nuestro servicio

El primer paso es configurar nuestro servicio y agregar algunos puntos adicionales a nuestro archivo application.conf para optimizar el desarrollo. Esta es la primera versión y ampliaremos este archivo en tutoriales posteriores.

Definir nuestro modelo

El primer paso es definir nuestro modelo. En este caso, es la raqueta (Racket). Lo haremos dentro de una carpeta/paquete llamada "racket". Tendrá un id, marca, modelo, precio, número de jugadores de tenis que la utilizan, una imagen, y la fecha y hora de creación y última modificación. Además, usaremos una constante de id para identificar las raquetas nuevas o existentes.

data class Racket(
    val id: Long = NEW_RACKET,
    val brand: String,
    val model: String,
    val price: Double,
    val numberTenisPlayers: Int = 0,
    val image: String = DEFAULT_IMAGE,
    val createdAt: LocalDateTime = LocalDateTime.now(),
    val updatedAt: LocalDateTime = LocalDateTime.now(),
    val isDeleted: Boolean = false
) {
    companion object {
        val NEW_RACKET = -1L
        const val DEFAULT_IMAGE = "https://i.imgur.com/AsZ2xYS.jpg"
    }
}

Desarrollando nuestro repositorio

El patrón de repositorio es un patrón de diseño que aísla la capa de datos del resto de la aplicación. El patrón de repositorio tiene dos propósitos: primero, es una abstracción de la capa de datos, y segundo, es una forma de centralizar el manejo de los objetos del dominio. La idea es tener una forma abstracta y genérica para que la aplicación pueda trabajar con la capa de datos sin importar si la implementación se dirige a una base de datos local, un archivo o una colección en memoria.

Los métodos se basan en las operaciones CRUD: Crear (Create), Leer (Read), Actualizar (Update) y Eliminar (Delete). En la primera versión, utilizamos un mapa como repositorio en memoria (en partes futuras utilizaremos una base de datos reactiva). Usamos funciones suspendidas (suspended functions), flows y tipos nulos (nullable types) para realizar el uso reactivo y asíncrono del repositorio. Utilizaremos interfaces para poder realizar la inyección de dependencias más adelante y cumplir con los principios SOLID. También utilizamos Kotlin Logging para mostrar los mensajes. Además, utilizamos un nuevo contexto y despachador (dispatcher) para ejecutar los métodos en un hilo (thread) especial y no suspender el hilo de la solicitud (request petition).

class RacketsRepositoryImpl : RacketsRepository {
   private val rackets = racketsDemoData()

   override suspend fun findAll(): Flow<Racket> = withContext(Dispatchers.IO) {
       logger.debug { "findAll" }

       return@withContext rackets.values.toList().asFlow()
   }

   override suspend fun findById(id: Long): Racket? = withContext(Dispatchers.IO) {
       logger.debug { "findById: $id" }

       return@withContext rackets[id]
   }

   override suspend fun findAllPageable(page: Int, perPage: Int): Flow<Racket> = withContext(Dispatchers.IO) {
       logger.debug { "findAllPageable: $page, $perPage" }


       val myLimit = if (perPage > 100) 100L else perPage.toLong()
       val myOffset = (page * perPage).toLong()

       return@withContext rackets.values.toList().subList(myOffset.toInt(), myLimit.toInt()).asFlow()
   }


   override suspend fun findByBrand(brand: String): Flow<Racket> = withContext(Dispatchers.IO) {
       logger.debug { "findByBrand: $brand" }
       return@withContext rackets.values
           .filter { it.brand.contains(brand, true) }
           .asFlow()
   }

   override suspend fun save(entity: Racket): Racket = withContext(Dispatchers.IO) {
       logger.debug { "save: $entity" }

       if (entity.id == Racket.NEW_RACQUET) {
           create(entity)
       } else {
           update(entity)
       }
   }

   private fun update(entity: Racket): Racket {
       logger.debug { "update: $entity" }
       
       rackets[entity.id] = entity.copy(updatedAt = LocalDateTime.now())
       return entity
   }

   private fun create(entity: Racket): Racket {
       logger.debug { "create: $entity" }
       
       val id = rackets.keys.maxOrNull()?.plus(1) ?: 1
       val newEntity = entity.copy(id = id, createdAt = LocalDateTime.now(), updatedAt = LocalDateTime.now())
       rackets[id] = newEntity
       return newEntity
   }

   override suspend fun delete(entity: Racket): Racket? {
       logger.debug { "delete: $entity" }
       
       return rackets.remove(entity.id)
   }

   override suspend fun deleteAll() {
       logger.debug { "deleteAll" }
       
       rackets.clear()
   }

   override suspend fun saveAll(entities: Iterable<Racket>): Flow<Racket> {
       logger.debug { "saveAll: $entities" }
       
       entities.forEach { save(it) }
       return entities.asFlow()
   }
}

Configurando nuestras rutas y endpoints

El siguiente paso es definir nuestras rutas para nuestros endpoints; para ello, debemos conocer perfectamente los verbos HTTP, los códigos de estado y respuesta y las solicitudes (Requests) y respuestas (Responses) utilizando el DSL de Ktor. Podemos utilizar la siguiente tabla como referencia:

Utilizamos una función de extensión llamada "racketsRoutes()" para definirlo y luego usamos esta función en nuestro plugin de enrutamiento (Routing).

fun Application.configureRouting() {
    routing {
        get("/") {
            call.respondText("Hello World!")
        }
    }

    // Add our routes
    racketsRoutes()
}

// Define endpoint
private const val ENDPOINT = "api/rackets"

fun Application.racketsRoutes() {

   // Repository
   val rackets: RacketsRepository = RacketsRepositoryImpl()

   // Define routing based on endpoint
   routing {
       route("/$ENDPOINT") {

           // Get all rackets --> GET /api/racquets
           get {
               logger.info { "Get all rackets" }

               // QueryParams ??
               val page = call.request.queryParameters["page"]?.toIntOrNull()
               val perPage = call.request.queryParameters["perPage"]?.toIntOrNull() ?: 10

               if (page != null && page > 0) {
                   logger.debug { "GET ALL /$ENDPOINT?page=$page&perPage=$perPage" }

                   rackets.findAllPageable(page - 1, perPage).toList()
                       .run { call.respond(HttpStatusCode.OK, this) }

               } else {
                   logger.debug { "GET ALL /$ENDPOINT" }

                   rackets.findAll().toList()
                       .run { call.respond(HttpStatusCode.OK, this) }
               }
           }

           // Get one racket by id --> GET /api/rackets/{id}
           get("{id}") {
               logger.debug { "GET BY ID /$ENDPOINT/{id}" }

               val id = call.parameters["id"]?.toLongOrNull()
               id?.let {
                   rackets.findById(it)?.run { call.respond(HttpStatusCode.OK, this) }
                       ?: call.respond(HttpStatusCode.NotFound, "Racket not found with ID $id")
               } ?: call.respond(HttpStatusCode.BadRequest, "ID is not a number")
           }

           // Get one rackets by brand --> GET /api/rackets/brand/{brand}
           get("brand/{brand}") {
               logger.debug { "GET BY BRAND /$ENDPOINT/brand/{brand}" }

               val brand = call.parameters["brand"]
               brand?.let {
                   rackets.findByBrand(it).toList()
                       .run { call.respond(HttpStatusCode.OK, this) }
               } ?: call.respond(HttpStatusCode.BadRequest, "Brand is not a string")
           }

           // Create a new racket --> POST /api/rackets
           post {
               logger.debug { "POST /$ENDPOINT" }

               val racket = call.receive<Racket>()
               rackets.save(racket)
                   .run { call.respond(HttpStatusCode.Created, this) }
           }

           // Update a racket by id --> PUT /api/rackets/{id}
           put("{id}") {
               logger.debug { "PUT /$ENDPOINT/{id}" }

               val id = call.parameters["id"]?.toLongOrNull()
               id?.let {
                   val racket = call.receive<Racket>()
                   // exists?
                   rackets.findById(it)?.let {
                       rackets.save(racket)
                           .run { call.respond(HttpStatusCode.OK, this) }
                   } ?: call.respond(HttpStatusCode.NotFound, "Racket not found with ID $id")
               } ?: call.respond(HttpStatusCode.BadRequest, "ID is not a number")
           }

           // Delete a racket by id --> DELETE /api/racquets/{id}
           delete("{id}") {
               logger.debug { "DELETE /$ENDPOINT/{id}" }

               val id = call.parameters["id"]?.toLongOrNull()
               id?.let {
                   // exists?
                   rackets.findById(it)?.let { racquet ->
                       rackets.delete(racquet)
                           .run { call.respond(HttpStatusCode.NoContent) }
                   } ?: call.respond(HttpStatusCode.NotFound, "Racket not found with ID $id")
               } ?: call.respond(HttpStatusCode.BadRequest, "ID is not a number")
           }
       }
   }
}

Probando en Postman

Finalmente, podemos probar nuestra API REST en Postman o cualquier otro cliente REST. Postman es un cliente famoso para probar API REST. Puedes configurar nuestra solicitud y probar las respuestas.

Conclusión

Hemos comenzado una serie de temas emocionantes para captar las ideas de la programación reactiva y generar una API REST.

Ahora tenemos un buen punto de partida para comenzar a trabajar. Hemos mostrado cómo funciona Ktor para desarrollar una API REST reactiva, pero aún tenemos mucho que mejorar en nuestro código. Pero no todo se puede hacer en el primer paso. Poco a poco iremos aprendiendo lo que necesitamos en los siguientes tutoriales.

Nos hemos centrado en crear nuestros primeros endpoints y probarlos en Postman. Pero todavía tenemos mucho por hacer en futuros tutoriales:

• Validar solicitudes.
• Manejo de errores y excepciones.
• Railway Oriented Programming.
• Uso de un método de caché.
• Uso de una base de datos reactiva.
• Subir archivos.
• Usar websockets para implementar notificaciones en tiempo real.
• Usar Koin para inyectar nuestras dependencias.
• Conexiones seguras con SSL/TSL.
• Autenticación y autorización con JWT.
• Pruebas de nuestros endpoints.

Tienes el código de este proyecto en GitHub. El código de esta parte está en Releases. Por favor, no olvides darle una estrella o seguirme para estar al tanto de nuevos tutoriales y noticias.

Puedes seguirlo commit por commit y utilizar el archivo de respaldo de Postman para probarlo.

Además, en Hyperskill, puedes profundizar y aprender todos los conceptos y más a través de diferentes temas y tareas que te ayuden a mejorar como desarrollador en tecnologías Kotlin.

Las siguientes trayectorias ofrecidas por JetBrains Academy en Hyperskill pueden ser un punto de partida perfecto. Encontrarás toda la información y explicación de los conceptos y técnicas mostradas en estos artículos. ¡No te los pierdas!

• Desarrollador Kotlin
• Desarrollador Backend Kotlin (Ktor)

Con estas trayectorias, adquirirás experiencia práctica trabajando con herramientas modernas y aprenderás cómo desarrollar aplicaciones del lado del servidor, mantener los datos persistentes en tus bases de datos y probar la funcionalidad de tus aplicaciones utilizando herramientas modernas.

Déjanos saber en los comentarios si tienes alguna pregunta o comentario sobre este blog. También puedes seguirnos en las redes sociales para estar al tanto de nuestros últimos artículos y proyectos. Estamos en Reddit, Twitter, LinkedIn y Facebook.

Resumen profesional de 2022

Este 2022 no ha sido un año fácil. Con él terminé mi primer curso académico en mi nuevo destino. Nueva ciudad, nuevo centro, nuevo contexto, nuevos compañeros/as, alumnado y dinámicas que aprender. Y es que, aunque digan que todos los centros se parecen, cada uno tiene sus particularidades. Te pueden gustar más o menos, pero son las que hay y te debes adaptar en parte a ellas.

Por un lado, yo venía de otro instituto donde los compañeros/as estaban muy unidos a nivel docente, compartiendo e implicándose la mayoría en proyectos educativos comunes. Esto hacía que determinadas estrategias de cómo entiendo el proceso de enseñanza-aprendizaje las tuviera muy asimiladas y formaban parte de mi día a día. Aquí las cosas son un poco distintas, pues al haber tantos ciclos, en donde yo me muevo, DAM, seguimos trabajando duramente entre todos/as para asentarlo y encontrar un equilibrio, que a veces se dificulta al no tener una plantilla fija. Nada del otro mundo.

El instituto es muy bueno, tiene un gran equipo directivo, muy buenas ideas, muy tentadoras y atrayentes, de todas las familias profesionales que lo componen.

A nivel personal, intenté aportar con mi trabajo, contactos y alianzas lo que me había marcado como objetivo en el 2021/2022. Algunas cosas se han conseguido, otras pues han chocado con la realidad, ya que quizás no era el momento y que yo, posiblemente, no analicé la situación correctamente y el impacto que pueden suponer estos cambios, y no se han podido llevar a cabo. Pero bueno, es parte del proceso. Y que conste que he encontrado un centro donde el equipo directivo ha confiado en mí desde el principio y parte de mis compañeros/as de departamento me han respaldado y ayudado en todo lo que he necesitado y eso no tiene precio.

Personalmente y profesionalmente seguí apostando por ofrecer lo mejor al alumnado. Fui elegido Kotlin Trainer Certified by JetBrains y con ello poder certificar unos mínimos profesionales para mi alumnado. Sigo como GitHub Campus Advisor, Embajador de GitKraken y mi centro es Campus de JetBrains, GitHub, Postman o Canvas, entre otras cosas. El proceso de certificación de JetBrains fue duro, pero enriquecedor, donde aprendí mucho de cada una de las etapas que tuve que superar. Y es que no es lo mismo ser un buen programador que ser un buen formador en una tecnología/lenguaje al nivel que exigen sus propios creadores. Y en esta certificación has de combinar ambas cosas.

Por otro lado, he conocido a gente maravillosa que me ha aportado profesionalmente y personalmente mucho. Aprender y colaborar con los demás es lo que siempre más me ha motivado. Antonio Leiva se ha convertido en uno de mis pocos amigos en mi nuevo contexto y, aparte, en un pilar de colaboración y aprendizaje. Sus formaciones son exquisitas, y está trabajando junto a su equipo para ofrecer lo mejor. Yo mismo me refuerzo en algunas de ellas. Te invito a que veas lo que te ofrece en su web: Devexperto.

Por otro lado, inicié mi etapa ayudando en algunos temas de JetBrains Academy. Primeramente, escribiendo algunos temas para los tracks de Kotlin, donde además asenté mis conocimientos de nuevo con su propio título, desde otro punto de vista de solo estudiante. Posteriormente, ayudando en la corrección/revisión de los mismos. Y es que la calidad de los contenidos de esta plataforma es muy buena, y es un placer poder colaborar en ella y aprender de la gente de su equipo, que tiene unos conocimientos y unas ideas muy interesantes para transmitir el aprendizaje de un lenguaje de desarrollo por una plataforma virtual. Esto ha hecho que aprenda lo que en otros países, centros de formación valoran en el aprendizaje de un lenguaje y cómo enfocan su aprendizaje. Al día de hoy soy parte responsable y experto en contenidos de Kotlin en esta plataforma. Un honor que confíen en mí para ello.

También colaboré asistiendo a algunas sesiones de trabajo del grupo de Vue.js Madrid, aunque han sido geniales, no hubo muchas. Espero que se retomen.

He ayudado a formar a otros compañeros/as y ha sido muy agradable. He aprendido mucho de ello y espero seguir haciéndolo mejor en las siguientes oportunidades, si las hay.

Sinceramente, me siento muy afortunado de poder conocer a gente tan maravillosa y poder colaborar con ellos/as. Y es que la colaboración es la clave del éxito. Y es que no hay nada mejor que poder aprender de los demás y poder aportar lo que sabes a los demás. Y si encima te encuentras con buenas personas como Antonio o Zoya, pues mejor que mejor. Han sido elementos fundamentales fuera del centro que me han dado el equilibrio y los retos profesionales que necesito.

Pero no todo ha sido agradable. Han existido situaciones que incluso me han hecho plantearme buscar otro lugar de trabajo y desarrollar mi carrera profesional en otro sitio. Pero bueno, es parte del proceso: no todo es color de rosa.

Retos para 2023

Pero, como he dicho, no todo ha sido perfecto. El 2022 ha sido un año complicado, que ha hecho que me replantee muchas cosas y extraiga conclusiones para aplicar directamente.

Primero y más importante, es encontrar motivación y sentirme bien en mi lugar de trabajo. Mi alumnado es bueno, los compañeros/as estupendos y el centro privilegiado. Pero muchas veces siento que no es mi lugar. Por supuesto, ese problema está en mí. Con las cosas que veo y no comparto, me cuesta ser cómplice o parte de ellas. No es culpa del centro, sino más del sistema. Creo que hasta que encuentre mi lugar voy a mantenerme al margen haciendo mi camino. Si me piden ayuda, allí estaré en lo que crea que pueda aportar, pero no lanzaré propuestas como el año pasado, salvo que tenga el consenso de la mayoría, para que no se vean como imposiciones o caprichos. Creo que desperdicié muchas energías en cosas que no han aportado nada. Y si este no es mi lugar, pues deberé buscar otro. No me voy a quedar en un sitio que no me hace feliz o, sobre todo, donde pueda desarrollarme profesionalmente.

Por otro lado, debo desprenderme de formas de trabajar anteriores. Estoy muy agradecido al CIFP Virgen de Gracia, pero aquí no se pueden hacer las cosas iguales. No se trata de que en un sitio sea mejor o peor, sino diferente. El contexto es distinto, lo que implica medidas distintas. Pero a veces parece que sigo de "duelo". Esto implicará también desprenderme de antiguas obligaciones, salvo las que me unen con su directora. Pero bastante tengo con mi día a día para mirar de reojo a otros departamentos. No es algo personal, pues los quiero y admiro un montón, pero es tiempo y recursos que a veces me cuesta dar y que interfieren en mi día a día en mi contexto actual. Además, ahora hay líneas de trabajo que nos separan y no nos permiten colaborar, por lo que tampoco podemos ponernos trabas a nosotros mismos para avanzar.

Me gustaría involucrarme en algún proyecto de innovación y colaborar en algo que en parte llene. Esa parte mía acostumbrada a investigar o buscar nuevas formas es como una llama que arde. Pero si eso implica tirar de personas, no sé si ahora estaré preparado tras lo sucedido este año. Pero como siempre aceptaré el reto. Me atrae la idea de colaborar con otros departamentos y aprender de su forma de trabajar en otras especialidades.

Mejorar como docente en la comunicación de contenidos es esencial. Al día de hoy, sé que mi alumnado es lo más importante. Voy a seguir intentando darles un valor añadido a los contenidos del día a día para su futura etapa profesional e intentar poner de mi parte para que solventen sus problemas. De hecho, voy a aplicar la máxima del Dr. Max Goodwin en New Amsterdam (una de las series con la que más estoy aprendiendo en distintos sentidos) y contestar siempre con "¿cómo puedo ayudar?" a cualquier persona que me rodee, sobre todo dentro del aula.

Me encantaría colaborar más con Antonio Leiva; si lo lees, ya sabes que me encantaría poder colaborar contigo en algún proyecto. Y si no, pues espero que algún día podamos hacerlo. Y es que me encanta tu forma de trabajar no por lo que se ve desde fuera, sino en tu día a día. Ya lo sabes. Aquí me tienes. Eso no quita de otras cosas que ya compartimos, jejeje.

Sobre el tema de proyectos de fin de grado y tutorías. Al día de hoy, comuniqué oficialmente que prefería no involucrarme y que me limitaría a lo que legalmente fuese necesario. No creo que pueda aportar nada en este campo, y tras algunas circunstancias que ya he comentado en entradas anteriores o en esta propia entrada, prefiero no hacerlo. Pero si alguien quiere que le ayude, allí estaré. Pero al día de hoy no saldrá de mí ser el tutor ni tribunal de nadie. Prefiero dedicar mi tiempo a otros quehaceres para el centro o la comunidad educativa y que repercutan directa o indirectamente en el alumnado, el propio centro o la comunidad en general. Sobre ser tutor de 1.º o de DAM, no sé si seguiré y si lo hago es por puntos para en el futuro, si es necesario para un futuro concurso de traslados, por si se necesitaran, nunca se sabe, ni está planificado.

Quiero darle sentido al término "servir como docente": no me refiero a ser utilizado; me refiero a la actitud o calidad de servicio.

Si sigo en DAM, cosa que también dudo ahora, me gustaría replantear su enseñanza. Me gustaría que distintos especialistas que estamos en el sector debatiésemos sobre el contexto actual, el tiempo que tenemos, las competencias demandadas por el sector, estrategias metodológicas consensuadas, pros y contras de tecnologías, o implicaciones e intereses de las empresas, etc. He intentado hablar con el Ministerio para crear una Skill de DAM y me gustaría retomar este tema con otras personas. También creo que deberíamos luchar por un reconocimiento de Unidades de Competencia de algunos módulos y contenidos que se dan en el ciclo. Pero bueno, esto da para otra entrada. Lo apunto.

Me gustaría que entre el alumnado, centro y profesores implicados, empezando por mí, hiciéramos un club de desarrollo de software para plasmar algunas ideas suyas, trabajar en proyectos y sobre todo dar rienda suelta a su creatividad e ideas. Yo me apunto a ello y con ello traer a distintos profesionales para que den su visión y aprendan de su experiencia.

Voy a hacer un libro gratis (o libros) siguiendo los recursos, contenidos, prácticas que ya tengo disponibles en mi GitHub para el aprendizaje de distintos módulos de DAM/DAW usando tecnologías como Kotlin, Vue.js o GitHub, siguiendo lo aprendido a lo largo de este tiempo. Y de paso mostrar dichos contenidos y prácticas en mi canal de YouTube. Además potenciaré mi web siguiendo ese camino. Quien quiera colaborar es bienvenido/a.

A nivel personal

No de lo profesional vivo. Pero claro, si falla esa pata que es muy importante para desarrollarse interiormente pues uno siente un vacío importante. Siempre lo digo y siempre me pasa. Necesito separar e intentar que lo profesional no afecte a lo personal y que no todos los compañeros/as tienen que ser amigos/as como en el pasado y limitarme en parte a cosas profesionales.

Leganés y Madrid es mi lugar (por ahora). Espero tener algún amigo más para salir y compartir. Tengo una buena base de gente del club de tenis. Pero espero construir un grupo de amigos más amplio de tenis y de otras inquietudes. Que mola mucho echarse unas risas, unas cervezas y hablar de cualquier cosa pasando un buen rato. Debo aprender a sacar lo mejor o lo que más me aporte del lugar donde vivo y recursos y sitios hay para ello.

Espero avanzar más con la guitarra y volver a disfrutar de ello. Otra cosa con la que se me quitan las ganas o con la que la motivación no ha sido la adecuada. Pero espero que este año sea diferente y adquiera nuevas rutinas.

Quiero conocer más sitios cercanos de donde actualmente vivo.

Y por supuesto, y lo más importante, espero devolver todo el apoyo, cariño y amor a mi gente y sobre todo a los que me aguantan, escuchan y apoyan todos los días, con los que siempre tendré una deuda pendiente y que son mi verdadera motivación para seguir adelante y mejorar día a día.

¿Qué es Vue.js?

Vue.js es un framework progresivo de JavaScript de código abierto para la construcción de aplicaciones web. Fue creado por Evan You, y es mantenido por él y por el resto del equipo de Vue Core. Vue.js te permite trabajar con plantillas, usar reactividad en tus aplicaciones web, enrutamiento y hasta stores de datos. No voy a explicarte todo lo que se puede hacer de Vue.js, sino por qué me aporta mucho más que el resto de frameworks.

Si quieres conocer un poco más de Vue.js debes mirar este documental.

¿Por qué Vue.js?

Esta es la gran pregunta. Siempre me he decantado más por el Back-end que por el Front-end. Si trabajaba en clientes, generalmente era en móvil. Veía mucho código en JS desorganizado, usando jQuery, que lo alejaba de la lógica de cómo hacer aplicaciones grandes donde se procesan datos.

A la hora de querer profundizar en frameworks del lado del cliente tuve la duda entre elegir Angular, React o Vue. Creo que casi todo el mundo ha pasado por eso. Debo recordar que desarrollo por gusto y particularmente, y no me muevo por intereses empresariales. Además, mi trabajo principal es la docencia, formación e investigación.

Angular lo rechacé no por otra cosa, sino por los "bailes" que hace Google. Lo he sufrido en móvil. React no me gusta cómo trabaja y de nuevo me veo a expensas de los intereses de Facebook. Vue.js me parecía una alternativa real, potente y en medio de ambas. Capaz de coger lo mejor de los dos. Es un proyecto libre y escuchan a la comunidad y están atentos a sus necesidades.

Para mí, Vue.js, se adapta muy bien a mi forma de desarrollar software. Desarrollo basado en la descomposición de componentes que interactúan entre ellos. Puedo usar JavaScript o TypeScript cuando lo deseo y sobre todo me ha encantado su ecosistema.

Ecosistema de Vue.js

Aquí es donde viene el punto fuerte. Vue.js no solo te permite hacer SPAs (Single Page Apps), tiene un ecosistema y una comunidad que lo hace bastante interesante y atrayente para mí. No solo se trata de hacer componentes que se comunican con eventos y propiedades, sino de ofrecer una serie de herramientas, utilidades y extras que te hacen más fácil el trabajo.

Vue CLI y Vite

Estos CLI te ofrecen toda la potencia para configurar y comenzar tus proyectos en Vue.js.

Vue CLI te ofrece todas las opciones para hacer tu proyecto una realidad a nivel de configuración. Vite es toda una revolución. De nuevo Evan lo ha vuelto a hacer ofreciéndonos una herramienta que realmente potencia tu desarrollo.

DevTools

Vue DevTools es una extensión para Chrome que te ofrece la posibilidad de poder analizar y depurar tu aplicación Vue. Con ella puedes analizar los componentes, sus eventos y propiedades. También puedes analizar el enrutamiento y los estados de tu store.

Vue Router

El sistema de enrutamiento de Vue, es uno de los que más me gustan. Eficaz y muy sencillo. Es modular, con rutas dinámicas, query, efectos de transición y mucho más. Sin duda no parecerá que estés en una SPA cuando navegues en tu navegador.

Vuex

El sistema de estado de Vue es realmente interesante. Se podría decir que se basa en el patrón Flux o Redux. Nos permite manejar el estado entre confirmaciones y mutaciones. Además, es compatible con las DevTools.

Mis preferencias en Vue.js

No solo de los proyectos oficiales vive el desarrollador de Vue.js. Y entre la multitud de proyectos de su ecosistema realizados por la comunidad me gusta destacar los que más uso.

Nuxt.js

Nuxt.js es un framework que se utiliza para el desarrollo de aplicaciones web. Podemos utilizar Nuxt.js para crear aplicaciones estáticas (static pages), de una sola página (SPA) o de servidor (SSR). Nuxt.js es un framework que trabaja sobre Vue.js; esto quiere decir que tenemos todo lo bueno de Vue.js, pero contando ya con una organización y configuración establecidas desde el principio, que ayudan al desarrollador a enfocarse al 100% en el desarrollo.

VuePress

Es uno de mis proyectos preferidos. Esta web está desarrollada con VuePress. Nació porque Evan y su equipo necesitaban un sistema para documentar los proyectos y hacer blogs, sin la necesidad de montar grandes aplicaciones como puede pasar en Nuxt.js para hacer SSR. Algo que te permita escribir documentación con Markdown. Además, se adapta muy bien a mi filosofía de trabajo jamstack.

Pinia

No digas que es una simple store, es la STORE. Pinia es uno de los proyectos que más feliz me ha hecho y más tiempo y dolores de cabeza me ha quitado. Uno de los problemas que le veo a Vuex es su rigidez y pasos extras para trabajar con tipos incluso en Vue3. Pinia, nos ofrece una visión de cómo debe ser una store moderna, efectiva, intuitiva, extensible y muy ligera. Es compatible con DevTools. He felicitado a Eduardo por su excelente trabajo y recomiendo utilizar Pinia en todos los proyectos que puedas. De hecho marcará los pasos del próximo Vuex 5.

Oruga

¿Componentes para Vue a los que les puedes aplicar cualquier estilo CSS? Eso es Oruga. Me encanta Bulma y me encanta Buefy. Muchos de mis proyectos parten de esa base. Pero es verdad que a veces buscas algo más, o simplemente quieres compatibilidad con Vue3. Oruga está creado por el equipo de Buefy, con la idea de no depender de un CSS, sino de usar lo que consideres más oportuno en tu proyecto. Walter ha hecho un trabajo fantástico con sus colaboradores. En su página web tienes un ejemplo de cómo usar distintos estilos para los mismos componentes.

Quasar

Uso Quasar cuando quiero una aplicación para todo. Es verdad que puedo usar Electron para Vue para mis aplicaciones de escritorio, o tecnologías como NativeScript o Ionic para crear aplicaciones móviles. Quasar me ayuda a crear todo lo que quiera fácilmente. Con Quasar puedes hacer casi de todo:

• SPAs (Single Page App)
• SSR (Server-side Rendered App) (con cliente PWA)
• PWAs (Progressive Web App)
• BEX (Extensiones para Explorador)
• Mobile Apps (Android, iOS, …) with Cordova or Capacitor
• Multi-platform Desktop Apps (usando Electron)

Otros

Seguro que me dejo muchos de los increíbles proyectos como VeeValidate, VueUse o Slidev, pero te invito a que mires VueAwesome y conozcas los proyectos alrededor de Vue.js.

Testing

Para testear nada mejor que Cypress y/o Jest usando Vue Test Utils. En esta entrada te explico cómo testar componentes y aplicaciones Vue.js.

Aprende Vue.js

Te recomiendo algunos de mis recursos favoritos para aprender Vue.js:

Recursos y grupos de trabajo

Documentación.

Escuela Vue. Sin duda mi lugar favorito. Aprenderás rápido y con calidad.

30 days of Vue.js.

Comunidad Vue.js Madrid. Grandes personas y profesionales donde intercambiar y aprender sobre Vue.js, ¿dónde mejor?

¿Alguno más? Compártelo en comentarios en las redes sociales.

Conclusión

Vue.js es un gran framework para crear aplicaciones web. Pero no es todo. Hay mucho más que puedes hacer con Vue.js como has visto. Su curva de aprendizaje es sencilla y se adapta a tu forma de desarrollar ofreciéndote toda la libertad para hacer las cosas. El límite está en tu mente y Vue.js te ayudará a alcanzarlo.

En mi repositorio tienes ya algunos proyectos tipo. Si necesitas algo más no dudes en contactar conmigo.

Un poco de historia

Kotlin es un lenguaje de programación de tipado estático, multiparadigma y multiplataforma que se ejecuta más ágil sobre la máquina virtual de Java y que también puede ser compilado a código fuente de JavaScript. Solamente con esto ya deberías prestarle toda la atención como desarrollador. Te facilita que con un solo lenguaje te muevas por el mundo de la JVM, la web y Node.js y dispositivos móviles, así como distintos sistemas operativos.

Piensa que es un lenguaje muy joven y que ha bebido de las mejores cosas que existen en los lenguajes actuales y que evoluciona rápidamente. Imagina que debes diseñar Java en el 2016. Ten por seguro que no lo harías como hace 30 años, pensando en la cantidad de programadores C/C++ que había y en hacer algo similar para ellos. Kotlin es una visión moderna de cómo debería ser un lenguaje de programación pensado para programar en los tiempos actuales.

Kotlin cubre todos los paradigmas, por lo que es ideal para enseñar: programación estructurada, modular, orientada a objetos y funcional. Además, como he dicho, es 100% interoperable con Java, por lo que puede usar todas sus clases y paquetes, lo que te da un abanico de librerías listas para usar y las de NPM, por ejemplo, si lo usas como lenguaje a compilar a JavaScript. Es Null-safe, lo que significa que no hay ningún problema con el manejo de null.

Desde mi punto de vista, el único problema de Kotlin es que ha estado muy ligado a lenguaje solo para Android. Esta es una de sus características, pero no la única, y aunque importante, hay mucho más que lo hacen un lenguaje potente, elegante y muy efectivo para desarrollar todo tipo de proyectos. Poco a poco te iré desgranando sus ventajas como lenguaje y como herramienta docente y quizás pueda convencerte de que lo uses.

Kotlin a nivel docente

¿Por qué aprender a programar con Kotlin o por qué enseñarlo?

Después hablaré de todas sus bondades técnicas, pero como docente que soy, y profesor en desarrollo de software, te voy a contar mi punto de vista de por qué Kotlin es un lenguaje muy bueno para aprender/enseñar programación.

Aprendizaje gradual

Kotlin te permite moverte siguiendo los distintos paradigmas existentes. Puedes usarlo como lenguaje para programación estructurada y modular, exprimir la programación orientada a objetos y asentar las bases de programación funcional.

Por ejemplo, cuando comenzamos un curso de programación usando Java, un simple "¡Hola, mundo!" tiene una carga conceptual enorme. ¿Qué hacemos? Podemos optar por pedirle al alumnado un acto de fe, obviar algunos conceptos o intentar explicarlos hasta "donde se pueda". Esto puede dar problemas como que el alumnado no entienda el porqué de algunos conceptos, o que no entienda qué es lo que hace el código, o que utilice por error o por defecto algunos elementos y adquiera vicios inapropiados, como el uso de static en todos lados.

Analicemos un "¡Hola, mundo!" en Java:

public class HolaMundo {
  public static void main(String[] args) {
    System.out.println("Hola mundo!");
  }
}

Como ves, nos aparecen varios conceptos como public (visibilidad), class (todo debe ser una clase sin haber comenzado los objetos), static (métodos de clases, sin ver OO), void (no devuelve nada), main (es el punto de entrada de la aplicación), String[] args (es un array de cadenas de texto), System (es una clase de Java que nos permite escribir en pantalla), out (indica la salida) println (es un método de la clase System que imprime en pantalla).

No voy a entrar si queremos hacer el típico programa que pida un dato o inicie un diálogo por consola y aparezca la clase Scanner y con ello la locura de por qué se hace así. Demasiada carga para tan poca cosa.

Repitamos el mismo ejemplo con Kotlin:

fun main() {
  println("Hola mundo!")
}

Kotlin está muy bien diseñado y te permite una curva de aprendizaje gradual, donde utilizas lo que necesitas cuando lo necesitas, evitando escribir o utilizar conceptos que no necesitas y pueden ser más complicados de entender cuando uno comienza a programar y usando la sintaxis justa en el momento justo, y no siendo tan verboso como Java.

A partir de aquí puedes ir aprendiendo y dominando nuevos conceptos desde tipos, funciones, clases, objetos, colecciones, funciones lambda, etc.

Sigues usando el ecosistema de Java

Todas tus clases, librerías y programas existentes en Java son 100% compatibles con Kotlin. Es decir, si tu programa necesita una clase de Java, puedes usarla en Kotlin. Puedes hacer uso de Maven para instalar librerías de Java en tu proyecto e incluso de Maven/Gradle para gestionarlo.

Di "hola" a JS

Además, Kotlin te permite ser compilado a JavaScript. Si necesitas aplicaciones que hagan uso de JavaScript, puedes usar Kotlin y luego convertirlo a JavaScript. Además, te permite no solo aplicaciones web, sino en Node.js, o usar frameworks como Express, React, etc. Tienes NPM a tu disposición para cualquier librería.

Lenguaje puente

Kotlin te permite saltar de Java a JavaScript, con una sintaxis a medio camino entre el primero y TypeScript. Aprendiendo Kotlin podrás migrar fácilmente a estos dos últimos.

Elementos de Kotlin

A continuación voy a resumirte elementos de Kotlin que pueden interesarte.

Programación estructurada y modular

• Kotlin es un lenguaje orientado a objetos con tipado estático. Aun así, define unos tipos como primitivos para facilitarnos su uso. También tenemos cadenas y arrays, ideales para comenzar a programar. De hecho, tiene los String Templates, que vienen fantásticos para no perderte concatenando elementos.
• El control de flujo se puede realizar con elementos conocidos como condicionales, bucles definidos e indefinidos. Destacamos el when, que es un condicional múltiple supervitaminado, y el for, que al moverse con rangos nos facilita no usar comparaciones tediosas que pueden provocar errores.
• Las funciones son otro punto a favor. Podemos definir funciones con un número variable de parámetros. Además, podemos definir funciones en línea, de extensión (de lo mejor que podrás encontrarte) y sobrecarga de operadores de la manera más sencilla.
• Seguridad ante nulos: el null es un problema y desde su concepción se ha tratado de evitar de distintas maneras. Es aquí donde Kotlin tiene uno de sus puntos fuertes gracias a su facilidad para detectarlos, protegerse ante ellos y hacer instrucciones que realicen alguna acción en caso de no serlo, sin recurrir a complicadas comparaciones u objetos Optionals.

Programación orientada a objetos

• Kotlin trabaja con clases y objetos: Clases. Podemos tener constructores en la misma definición de clase e inicializadores. Para instanciar no necesitamos new.
• La herencia es simple para clases, pero múltiple para interfaces. Los métodos y variables de clase se incluyen en los objetos de tipo "companion", lo que los dota de esa característica especial que tiene un elemento de clase.
• Las propiedades y los getter&setter ya van de serie y depende de su visibilidad y si se definen como var o val (variables o constantes). De esta manera podemos implementar el patrón Builder de una manera muy simple.
• Clases específicas: gracias a notaciones como Data podemos crear clases para solo almacenar datos (típicas POJO en Java) en una sola línea. Con Object podemos crear clases siguiendo el patrón Singleton. Con todo lo indicado quizás no necesitemos recurrir a Lombok más.

Kotlin

data class Person(var name: String, var surname: String, var id: String)

Java

public class Person {
  private String name;
  private String surname;
  private String id;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getSurname() {
    return surname;
  }

  public void setSurname(String surname) {
    this.surname = surname;
  }

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  @Override public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    if (name != null ? !name.equals(person.name) : person.name != null) return false;
    if (surname != null ? !surname.equals(person.surname) : person.surname != null)
      return false;
    return id != null ? id.equals(person.id) : person.id == null;
  }

  @Override public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + (surname != null ? surname.hashCode() : 0);
    result = 31 * result + (id != null ? id.hashCode() : 0);
    return result;
  }

  @Override public String toString() {
    return "Person{" +
    "name='" + name + ''' +
    ", surname='" + surname + ''' +
    ", id='" + id + ''' +
    '}';
  }
}

• Genéricos: con ellos podemos dotar de toda la potencia de la programación genérica, pensando en qué queremos hacer y no con qué tipo.

Colecciones

Vale, podría ir en el apartado anterior. Aparte de poder usar todas las de Java, Kotlin tiene una serie de colecciones que puedes usar con una característica muy importante: poder trabajar con la mutabilidad e inmutabilidad.

De esta manera podemos trabajar, por ejemplo, con listas constantes de solo lectura. Una gran ventaja para no meter la pata. Es decir, una lista de solo lectura, que sería un dolor de cabeza en Java, aquí la tienes de serie. Por supuesto todas trabajan con estructuras funcionales si se da el caso, sin recurrir a los streams como parche o transformando los objetos.

Programación funcional

Kotlin es un lenguaje que se mueve muy bien con la programación funcional y las lambdas, pues fue concebido para ello y no es un añadido como en otros lenguajes. Por lo que todo resulta muy natural y sencillo, pues bebe de su "primo" Scala.

A partir de aquí tenemos una serie de operaciones usando este paradigma para el manejo de colecciones. Operaciones para realizar transformaciones, filtrado, adiciones y sustracciones, agrupamiento, recolección de datos, ordenamiento o funciones de agregación. Lo que necesites y más.

Programación concurrente

Kotlin puede hacer uso de hilos, callbacks y futures (promesas de Java) para hacer uso de la programación concurrente y mecanismos de sincronización conocidos (semáforos, monitores, synchronized, etc.). Pero su punto fuerte es el uso de las corrutinas. Una corrutina (definida también como un hilo liviano y optimizado) es un conjunto de sentencias que realizan una tarea específica, con la capacidad de suspender o reanudar su ejecución sin bloquear un hilo. Esto permite que tengas diferentes corrutinas cooperando entre ellas, suspendiéndose y reanudándose en puntos especificados por ti o por Kotlin. Con ellas podemos ejecutar código en paralelo y/o asíncrono de una forma muy sencilla y óptima. No significa que exista un hilo por cada corrutina; al contrario: puedes ejecutar varias en uno solo.

suspend fun fetchTwoDocs() =
  coroutineScope {
    val deferredOne = async { fetchDoc(1) }
    val deferredTwo = async { fetchDoc(2) }
    deferredOne.await()
    deferredTwo.await()
}

Con ellas podrás crear tu propio procesamiento concurrente optimizando los recursos del sistema. Este comportamiento de las corrutinas en Kotlin te permite:

• Reducir recursos del sistema al evitar la creación de grandes cantidades de hilos.
• Facilitar el retorno de datos de una tarea asíncrona.
• Facilitar el intercambio de datos entre tareas asíncronas.

Programación de servicios

Kotlin te permite trabajar con el Back-end de tu aplicación de manera muy efectiva. Puedes usar Spring sin ningún problema y con una gran cantidad de funcionalidades. Si tu excusa para no usar Kotlin en el back era Spring, ya se te ha acabado. Con ello podrás hacer, por ejemplo, tu API REST.

Pero quizás quieras crear servicios web de una manera asíncrona y sencilla. Kotlin pone a tu disposición Ktor para ello. No necesitas Spring o Express para hacer una API REST o GraphQL de manera rápida.

Por otro lado, puedes usar JPA sobre Hibernate o Spring Data para trabajar en tu acceso a datos a cualquier tipo de base de datos. También podemos usar JAXB para XML, o GSON o Jackson para JSON, Java NIO2 o las propias funciones de Kotlin para ficheros.

¿Quieres más? Necesitas moverte con Node.js. ¿Un back sobre Express?, ¿librerías de NPM? Con Kotlin puedes hacerlo. Puedes crear tus aplicaciones en Node.js.

Desarrollo de clientes

Con Kotlin puedes crear el cliente que quieras o como quieras. JVM: puedes usar JavaFX o cualquier paquete de Java para implementar tu cliente. JavaScript/Web: puedes usar Kotlin para crear tu cliente o aplicación web como lenguaje tipado. Puedes trabajar en Vanilla JavaScript o con frameworks tan conocidos como React.

Por supuesto puedes trabajar para móviles: todos conocemos su potencial sobre Android. Pero además nos permite realizar desarrollos para iOS.

Pero el gran paso para poder hacerlo todo y en todas las plataformas con Kotlin es Compose, o cómo crear interfaces de usuario de manera declarativa y con ello poder crear nuestras aplicaciones para Windows, Mac, Linux, Android, iOS, web, etc.

Testing

Obviamente para nuestros tests podemos hacer uso de JUnit o Mockito. Pero además tenemos nuestras librerías propias para ello.

Desarrollo nativo

Si tu problema es el escepticismo del rendimiento sobre JVM, también puedes desarrollar nativamente con interoperabilidad con C u Objective C.

Ciencia de los datos

Kotlin puede ser una gran alternativa para la ciencia de los datos. Puedes usar sus librerías e integración, por ejemplo, con terceros.

DSL y Kotlin

Kotlin puede ser usado como lenguaje de dominio específico para resolver determinadas tareas de una manera rápida y muy legible.

Patrones de diseño

Kotlin puede ser usado sobre patrones de diseño y aprovechar su sintaxis para hacerlos más asequibles y fáciles de implementar: ya hemos hablado de cómo conseguir por ejemplo Singleton con la notación object. A continuación mostramos un simple ejemplo para el patrón Builder.

class FoodOrder private constructor(
  val bread: String?,
  val condiments: String?,
  val meat: String?,
  val fish: String?) {

  data class Builder(
    var bread: String? = null,
    var condiments: String? = null,
    var meat: String? = null,
    var fish: String? = null) {

      fun bread(bread: String) = apply { this.bread = bread }
      fun condiments(condiments: String) = apply { this.condiments = condiments }
      fun meat(meat: String) = apply { this.meat = meat }
      fun fish(fish: String) = apply { this.fish = fish }
      fun build() = FoodOrder(bread, condiments, meat, fish)
    }
}

Shell y Scripting

Quizás te guste Node.js y su consola. Si ejecutamos el compilador sin parámetros, entraremos en la consola de Kotlin, donde podemos ejecutar código de Kotlin y ver sus resultados.

Además podemos usar Kotlin como lenguaje de scripting con ficheros .kts. Un ejemplo:

Ejemplo de script llamado:

import java.io.File
// Toma el path pasado en -d, o el path actual
val path = if (args.contains("-d")) args[1 + args.indexOf("-d")]
else "."
val folders = File(path).listFiles { file -> file.isDirectory() }
folders?.forEach { folder -> println(folder) }

Podemos llamarlo como:

$ kotlinc -script list_folders.kts -- -d <path_folder>

Kotlin vs Java

No se trata de una guerra, sino de que cada cual elija según sus intereses programando.

Aprende Kotlin

Cursos y documentación

Documentación

Ejemplos

Koans

JetBrains Coursera.

JetBrains Academy.

En YouTube, mis preferidos y siempre recomendados son:

Antonio Leiva DevExperto.

Brais Moure MoureDev.

Conclusión

Kotlin ha supuesto un gran avance en el ecosistema de la JVM; de hecho, muchos de los avances de Java desde la versión 8 vienen de "inspirarse" en Kotlin. No voy a negar que coincido con las palabras de un desarrollador del ecosistema de Spring: "Lo mejor que le puede pasar a un desarrollador de Java es codificar en Kotlin". También espero haber conseguido que dejes de ver a Kotlin como el lenguaje que solo sirve para programar en Android y lo tengas en cuenta para más tipos de desarrollos.

Uno de los objetivos que tengo pendientes, y quiero realizar, es mostrar cómo muchas partes del temario de DAM y DAW se pueden desarrollar con Kotlin. Para ello realizaré apuntes y prácticas tipo. Los compartiré en mi repositorio y web. De hecho, como ves, cubre todo el temario de ambos ciclos y más. Deseo que tú, como alumno o docente, te animes a usar Kotlin, no solo para Android, y con esta entrada hayas descubierto cómo este lenguaje te puede aportar experiencias muy positivas para tus desarrollos. Y si podemos compartirlo, mucho mejor.

En mi repositorio tienes ya algunos proyectos tipo. Si necesitas algo más, no dudes en contactar conmigo.

El mundo del desarrollo de software y sus cambios

El mundo del desarrollo del software es un mundo cambiante, algo volátil y a la vez muy conservador. Esto quiere decir que todos los días aparecen librerías, frameworks o versiones de lenguajes, pero que estos se establezcan como referentes es complicado. A la vez, aparecen términos que se ponen de moda y muchos los abrazan como nuevas religiones (incluso creando fanatismo por ellos) o se rescatan antiguas canciones, como los grandes éxitos de los años pasados que vuelven a estar de moda, o simplemente se les maquilla un poco y se les da una nueva terminología.

Lo que busco al programar

Debo identificar parte de mis tres facetas: el profesor, el desarrollador profesional y el desarrollador a nivel personal. Algunas poco a poco se van entremezclando.

En esta misma web, en el apartado de Tecnologías, encontrarás una lista de las tecnologías que he utilizado con más frecuencia.

A nivel docente, uso lo que creo más adecuado dependiendo del marco empresarial donde mi alumnado se va a incorporar. No me caso con temarios antiguos o tecnologías concretas. Mi protagonista es mi alumnado y a él me debo. Mi obligación es que se incorpore a las empresas de desarrollo con garantías de desarrollar su potencial desde el comienzo. La ley me marca unas competencias, me fija unos contenidos básicos, pero yo elijo de acuerdo al contexto cómo y con qué.

A nivel profesional, a veces los clientes buscan algo específico, pero también quieren una solución que se adapte a sus necesidades. Muchas veces escuchan determinadas propuestas; otras, como profesional que uno es, pues implementa una solución que se adapte a las necesidades de los clientes con las tecnologías indicadas.

A nivel personal, no me caso con nadie y, como con la música o las series, tengo mis gustos. Pero siempre busco lo mismo: efectividad y calidad. Si puedo "matar varios pájaros" de un tiro, lo haré (lo admito, soy vago). Y como bien se dice, "para gustos, colores" y como además me lo puedo permitir, hago lo que quiero y como quiero, pero siempre con coherencia. También busco escapar de la monotonía de enseñar siempre con lo mismo y de algunas caras de "asco" que me encuentro entre las aulas.

Preferencias en Front-end

Aquí es donde he tenido siempre las cosas claras. Trabajo con JavaScript o TypeScript, pero siempre con Vue.js. ¿Por qué? Un día daré los motivos, pero puedo hacer desde aplicaciones web, escritorio (Electron) o móviles (Quasar, Ionic, NativeScript). Lo acompaño de Pinia como store de referencia. Esa es la base. Además puedo usar Tailwind, Windi CSS y Bulma como ayuda para el CSS. Aprovecho las virtudes de Oruga y Quasar para hacer lo que quiero. Hasta esta web está hecha con Vue.js.

Preferencias en Back-end

A día de hoy me muevo de nuevo en el mundo de JavaScript y TypeScript con más comodidad gracias a Node.js. Con ello desarrollo REST y GraphQL si es el caso. Si necesito ir a Spring recurro a Kotlin. Quizás por la pesadez de darlo siempre en clase rehúyo de usar Java. Me parece pesado y antiguo, y aunque desde Java 8 me gusta, creo que Kotlin me aporta mucho más. Para mí no es el lenguaje de "solo Android", es mucho más y me gusta para muchos aspectos de back-end. Estos días hablaré de ello. Para almacenamiento me muevo entre Firebase, MongoDB y MariaDB principalmente, dependiendo de lo que vaya a hacer.

Preferencias en desarrollo móvil

Reitero lo anterior: JavaScript, TypeScript, Vue.js y Kotlin. No necesito más. Eso sí, con sus añadidos.

Repositorios y despliegues

Aquí lo tengo muy claro. Siempre GitHub y GitKraken. Esta web incluso la despliego en GitHub Pages con GitHub Actions. GitKraken es mi herramienta de cabecera. Luego puedo usar Firebase, Heroku y Netlify. No puedo vivir sin Docker, y es una de las herramientas que más utilizo. De hecho, esta página web sigue la filosofía JAMstack. Me muevo entre Jest, JUnit y Mockito para test.

Mis IDEs y herramientas

Aquí vuelvo a tener las cosas muy claras. Ganan por goleada Visual Studio Code como editor y JetBrains (IntelliJ IDEA) como IDE. Ambas opciones por potencia y personalización. Y como curiosidad uso ZSH como shell de terminal, tanto en Linux como en Mac. No uso Windows para programar.

Conclusión

No voy a engañar a nadie, quizás no sean las mejores opciones, pero me parecen efectivas a nivel personal para lo que hago, y como bien remarco, es a nivel personal. Obviamente profesionalmente me muevo por mucho más. Pero esta entrada quería hablar de cómo disfruto más y de qué me hace sentir más productivo. Y muchas veces lo hago asqueado por modas o tendencias, que lo único que hacen es refritos de conceptos ya existentes y a veces utilizándolos erróneamente. Pero eso dará para otra entrada.

Programación y Docencia

Está claro que cuando enseñas buscas dos cosas: un lenguaje con el que desarrollar unas competencias demandadas por la industria, donde poder desarrollar un marco teórico-práctico. A veces no es el mejor o peor, sino el más adecuado.

En mi anterior centro, el conjunto de profesores cambiábamos de lenguaje con el objetivo de que el alumnado no fuera dependiente y aprendiera a discernir entre las ventajas e inconvenientes de cada uno de ellos. Creo que esto era una gran ventaja y virtud. De hecho, se desarrollaban diversas habilidades mucho más rápido y el alumnado podría aprender en DAM: Java, Kotlin, C#, Python, Dart con Flutter, etc. Mientras en DAW tenían Java, PHP, JavaScript, TypeScript. Sin hablar de frameworks, como Spring Boot, Laravel, Express, etc. Conclusión: alumnos más demandados y completos.

Este año, en mi nuevo centro, esto no es así. La apuesta principal en DAM es con Java. Es lógico, porque es un lenguaje base para enseñar todo. Obviamente otros profesores enseñan Python o PHP, pero todo se resume a usar JAVA como protagonista.

Más allá de JAVA

No voy a negar que Java me puede gustar más o menos, o que hay alternativas mejores. De hecho, este año en Programación he cambiado de lenguaje para usar dos distintos y el año que viene me planteo algunas cosas darlas con Kotlin, como este año ha sido TypeScript. Puedo desarrollar los mismos conceptos con ellos y así rompo la dependencia de asociación que crea el alumnado con el lenguaje. Para mí es muy importante que programen con la cabeza. El lenguaje es solo un instrumento y veo fundamental desarrollar los contenidos sin crear esa dependencia.

En cualquier caso, cuando lleguen a una empresa nadie les asegura que vayan a trabajar solo con Java y deben ser capaces de explotar lo aprendido con cualquier lenguaje.

No voy a negar que Java ha mejorado mucho, que cada vez es más ágil: API Stream, menos verboso y muchas más cosas. La mayoría de ellas sacadas de su primo Kotlin y de la propia evolución de otros lenguajes. Pero sigue sin gustarme. Y no me gusta cuando veo esa imposición a usarlo docentemente para todo y sacrificar la libertad que el conocer distintos lenguajes te puede dar para expresarte como desarrollador. No me gusta el "only JAVA". Me frustra ver estadísticas de mi perfil con las horas de su uso y ver que a mí no me motiva. Lo entiendo y lo avalo como docente, pero sé también que hay que trabajar para no depender solo de él teniendo excelentes alternativas y que el paso de una a otra es cada vez menor. Por ejemplo, de Kotlin a Java te sirve todo y además ya existe hasta la plantilla de Spring Boot.

Conclusión

Me gusta Java, sí, pero no es lo único que se debe aprender. Y animo a mi alumnado a que no se sienta encorsetado ni atado a ello. Cada día son más fáciles los cambios, y si tú aprendes conceptualmente a programar (o usas la cabeza) verás que el lenguaje es solo el medio. Y más sabiendo que muchos beben de la misma sintaxis del "abuelito" C.

"Elige siempre lo que te haga ser más productivo y ágil para el problema que vas a resolver".

Alguien que pensó en eso 😀

El problema de la inmediatez

En esta sociedad en la que vivimos, nos hemos acostumbrado a que todo está a un clic de distancia: desde mandar un mensaje a buscar información, delegando en ello lo que Google nos quiera mostrar. Poco a poco nos olvidamos de que hay algunos problemas que requieren maduración o simplemente asimilar que no se resuelven con un simple clic.

Desarrollar aplicaciones informáticas consiste en resolver un puzle aplicando distintas piezas, partiendo de un análisis del problema, diseñando la solución, pasando a la implementación de la misma, para comprobar y verificar que funciona y es válida.

Al vivir en el mundo de la inmediatez y de un solo clic, queremos suprimir las dos primeras etapas y codificar todo sin pararnos a analizar para luego diseñar la solución. Pero es que programar no solo es codificar en un lenguaje: es descomponer un problema en pasos, una serie de sentencias, estructuras, objetos, usar librerías... No se trata de escribir por escribir.

Y es ahí donde nace el problema. Si lo unimos al problema de base de que se ha partido de no fomentar esta etapa, nos encontramos con proyectos de desarrolladores/as que son incapaces de resolver un problema porque no tienen la paciencia necesaria para llegar a la solución o simplemente para aceptar el reto de resolverlo. Y no es la primera vez que parte de mi alumnado se deja los módulos por no saber gestionar estas situaciones.

Aceptando el reto

Y he hablado de reto. Porque programar es resolver problemas que a veces nos retan y, como todo reto, implica aceptar la frustración inicial de no tener los medios para resolverlos, investigar para ello, alcanzar las competencias necesarias y posteriormente intentarlo. Esto no nos garantiza que lo consigamos a la primera, pero si nos rendimos nunca lo conseguiremos. Eso creo que está claro.

Frustración

Cuando desarrollamos, debemos aprender a lidiar con la frustración y con aquella parte de nosotros que nos boicotea diciendo que no servimos. La verdad es que, como nos han inculcado que todo es fácil y maravilloso, que vivimos en un mundo ideal donde con un clic todo se hace realidad, nos olvidamos de que las soluciones hay que trabajarlas y que madurar algo implica dar pequeños pasos pero constantes hasta conseguirlo. A veces tropezaremos, pero no debemos desistir. Siento decirte que no todo es fácil, pero no nos olvidemos de que todo es posible (la mayoría de las veces).

Ten la mente abierta

Por otro lado, siempre habrá el alumno/a que ante nuevos contenidos, técnicas o herramientas se vea reacio/a a aplicarlos. Total, si ya sabe resolverlos, ¿para qué complicarse? Bueno, pues porque hay que avanzar, aceptar el reto, y cuantas más herramientas técnicas dominemos mejor podremos afrontar nuevos problemas. No todo se resuelve con un martillo o destornillador: a veces necesitaremos un bisturí. El problema es que no gestionan bien la salida de su zona de confort. Pero retarnos, seguir avanzando y autoaprender es una obligación.

Fallar está permitido

A día de hoy, nunca le he dicho a mi alumnado que no se puede fallar. Y tampoco conozco a nadie que nunca haya fallado. De hecho, yo mismo he aprendido mucho más solucionando un error o bug de dos horas que si me hubiese salido todo a la primera. Gracias a ese bug he investigado varias soluciones alternativas o he comprendido cómo funciona una librería determinada. Me ha hecho crecer. Seguiré fallando, lo sé, me lo permito. Fallaré nuevamente y fallaré mejor. Seré constante. Leeré el error que me lance el IDE y aceptaré dicho reto. Como pone el tatuaje de uno de mis tenistas favoritos, Stan Wawrinka:

"Always tried, always failed, no matter, try again, fail again, fail better".

Samuel Beckett

Quizás esa educación de jugar al tenis, de fallar y olvidarse, de ir a por el siguiente punto sin quedarse en el error, me inculcó esa capacidad. Piensa en Rafa Nadal: siempre se le ha valorado su mentalidad.

La solución parte de ti

Una buena actitud proactiva te va a ayudar mucho. No te lances mensajes negativos, pero tampoco vayas con un exceso de confianza. La peor de las batallas son las que no nos atrevemos a luchar y en las que nos rendimos antes de hacerlo. Para recoger la cosecha antes hay que sembrar, y te vas a ensuciar las manos. Esto es un viaje. Si aprendes estos hábitos, poco a poco lo conseguirás. Es verdad que no todo el mundo madura y crece como programador al mismo ritmo. Pero no te voy a engañar: hay cosas que no conseguirás y deberás aceptar dicha derrota para poder seguir avanzando. Uno no se ahoga por caer en el mar, sino por quedarte sumergido en él.

Tampoco busques excusas ni eches balones fuera. Nunca has tenido tantos medios para aprender. El profesor no es tu enemigo. Piensa también en lo que aportas tú en este proceso de formación en el que te encuentras.

No será la primera vez que Son Goku debe entrenar para salvar el universo y la tierra. No era el más talentoso ni el más listo, pero se dejaba la piel y aceptaba el reto.

Gestiona la frustración, permítete fallar, comprende que hay que seguir avanzando y aprendiendo cosas nuevas y que nada es inmediato.

Para terminar te dejo un ejemplo de superación de adversidades. Como me gusta mucho la guitarra y el rock, Tony Iommi es un ejemplo de no darse por vencido y buscar soluciones para llegar a tu meta, y de paso convertirse en un pionero. Te invito a que conozcas su historia.

Zona de confort y los retos

La zona de confort es la zona en la que estás cuando te mueves en un entorno en el que dominas y las cosas te resultan conocidas y cómodas. Tus hábitos, tus rutinas, tus conocimientos, tus aptitudes y tus comportamientos son tu zona de confort porque los conoces. Después del cambio a Córdoba y de volver a Puertollano, aprendí que uno no debe aspirar solo al reconocimiento profesional y vivir en ese confort. Ese sentimiento se vio amplificado en los meses de aislamiento del COVID-19.

Profesionalmente he vivido de todo: desde dar conferencias y trabajar en investigación hasta dar clase en todo tipo de centros y niveles de estudios, no solo académicos, sino quedarme helado en pistas de tenis. Me he sentido y me siento afortunado por ello.

He tenido la suerte de conocer gente maravillosa en mi viaje. Pero el confort profesional a veces es perjudicial. Siempre he tenido inquietudes tanto profesionales como personales y, a veces, es necesario "pegarle una patada a lo conocido" y adentrarse en la aventura para sentirse vivo, incluso con los miedos o inseguridades que eso pueda provocar y, si nos dejan, poder soñar un poco más y afrontar nuevos retos. No es fácil.

Hasta luego, CIFP Virgen de Gracia 👋

Si hay un instituto donde puedes realizarte como docente es el CIFP Virgen de Gracia. Su nivel académico, técnico y, sobre todo, humano es insuperable. A lo largo de estos años he ejercido como docente, tutor y jefe de departamento, y siempre he aprendido de todos/as mis compañeros/as. Son una familia. De hecho, en tiempos duros donde no he podido ver a mis seres queridos (COVID-19), ellos han llenado ese hueco. Desde el principio me abrieron sus brazos, me dejaron material y confiaron en mí otorgándome responsabilidades, ya sea con la jefatura o con proyectos de innovación.

Gran parte de la culpa la tiene su equipo directivo, siempre dispuesto a apoyar a los demás, mis compañeros de departamento (mi familia) y el resto de compañeros de centro y de rueda. Desde que te levantabas y compartías rueda hablando de todo hasta los follones en los que nos metíamos en el departamento inventando cosas, la sensación de sentirte realizado como persona y docente nunca ha sido mejor.

No me gusta dar nombres porque ellos lo saben, pero parte de lo que soy a día de hoy es gracias a ellos. He encontrado almas gemelas que entienden como yo la docencia del desarrollo de software; he recibido consejos y ayuda que me han hecho crecer y ser mejor a día de hoy. Mi gran objetivo siempre ha sido devolverles con mi esfuerzo y trabajo diario todo lo que me aportaban en mi día a día. Supongo que a veces me equivoqué y les pido disculpas por ello, porque nadie es perfecto. Pero sí quiero darles las gracias por todo lo que han hecho por mí y por el docente que me han hecho ser.

No les voy a decir adiós porque espero que nuestros caminos se entrecrucen muchas veces en nuestra vida. Yo siempre estaré disponible para ellos.

Hola, Luis Vives 🙌

Mi nuevo centro es el IES Luis Vives de Leganés, en Madrid. Todo es nuevo y es una nueva aventura: desde dónde vivir hasta a dónde ir o cómo será el centro. Poco puedo decir...

Una cosa tengo clara: confío en mi trabajo y en lo aprendido a lo largo de mi vida. El reto es grande y da mucho respeto. Pero paso a paso vamos caminando.

De paso, como ya he dicho, espero además crecer personalmente junto a aquellos/as que me han apoyado y me han dado oportunidades a nivel personal, y poco a poco hacer mi propio camino y ver dónde este me lleva.

«Cada uno de nosotros está en la tierra para descubrir su propio camino, y jamás seremos felices si seguimos el de otro».

James van Praagh

Vue Weather Testing

El objetivo de este proyecto es partir de una simple aplicación realizada en Vue.js que consulta el tiempo de una ciudad (buscador) usando OpenWeatherMap API y, en base a ella, mostrar distintas formas de realizar los test usando Jest y Cypress dentro de Vue Test Utils.

No es tanto el aspecto estético, sino el interno, mostrando cómo realizar test unitarios, de integración y E2E sobre una app Vue.js, donde se pueda ver cómo testear tanto un componente aislado y dentro de este sus propiedades y métodos, como la interrelación de distintos componentes que dan forma a esta aplicación, así como la app como un todo.

Antes de seguir, os puedo indicar que prepararé un ejemplo de aplicación de la metodología TDD donde abordaremos también el uso de Jest y Cypress para realizar pruebas de nuestros proyectos y cuyas referencias y repositorios indico a lo largo de esta entrada.

Este proyecto puede verse como una continuación del contenido mostrado en:

• Testing JS con JEST
• Testing JS con Cypress

Testeando con Vue Test Utils

Jest

Jest es una de las posibilidades que tenemos para testear nuestro código o proyecto en Vue.js. Se define como la suite de "test con 0 configuración"; es decir, mientras otras suites de test necesitan de un motor (test runner) para pasar los test y de la propia suite de test, así como de una librería de aserciones o matchers, Jest intenta que todo esto esté ya agrupado para agilizar el proceso de test desde el principio. Esto no quiere decir que no se pueda ampliar o profundizar y personalizar con otras librerías o que no tenga la potencia de otros, y está pensada para test unitarios y de integración.

ShallowMount vs Mount

• shallowMount: nos permite cargar un componente de manera individual para testearlo, creando un wrapper pero sin componentes hijos.
• mount: carga el componente y sus componentes hijos.

shallowMount() es mejor para probar un componente individual de forma aislada, ya que los componentes secundarios (hijos) se eliminan. Es ideal para las pruebas unitarias. Además, el uso de shallowMount() para probar un componente con muchos componentes secundarios (hijos) puede mejorar el tiempo de ejecución de la prueba unitaria, ya que no hay ningún costo (en términos de tiempo) para renderizar o usar los componentes secundarios (hijos).

mount() es útil cuando desea incluir la prueba del comportamiento de los componentes secundarios (hijos) en el test.

El objeto wrapper nos permite probar todos los aspectos del HTML generado por el componente Vue y todas las propiedades (como los datos o métodos) del componente Vue.

Aserciones y Matchers

Los Matchers nos permiten comparar de diferente manera valores esperados con los obtenidos. Podemos hacerlo de la siguiente manera, aunque hay más:

Igualdad

• .toBe: usado para comparar valores primitivos.
• .toEqual: usado para comparar recursivamente todas las propiedades de un objeto, también conocido como igualdad profunda.

Numéricos

• .toBeLessThan: el valor es menor que.
• .toBeLessThanOrEqual: el valor es menor o igual que.
• .toBeGreaterThanOrEqual: el valor es mayor o igual que.
• .toBeGreaterThan: el valor es mayor que.

Boolean, Nulos y Undefined

• .toBeTruthy: el valor es verdadero.
• .toBeFalsy: el valor es falso.
• .toBeUndefined: el valor es 'undefined'.
• .toBeNull: el valor es 'null'.

Arrays y contenido

• .toContain: contiene el elemento dentro del array.
• .toHaveLength: el array tiene la longitud.

Strings

• .toMatch: comprueba que un texto coincide con una expresión regular.
• .toHaveLength: comprueba la longitud.
• Podemos usar otros anteriores.

Uso de Mocks

Simulamos las llamadas a la API REST sin salir al exterior. De esta manera:

• Simulamos peticiones a la API REST satisfactorias.
• Simulamos llamadas a la API REST que fallan. Usando los mocks, podemos ver cómo reaccionan nuestros componentes sin necesidad de "gastar" tiempo en llamar constantemente al servicio externo.

Estructura de un test

import { shallowMount } from '@vue/test-utils'
import App from '@/App.vue'  // Importa el componente a testear
import axios from 'axios'    // Importa la librería a mockear

// Mockeamos las librerías que vamos a usar
jest.mock('axios')

// Describimos la suite de test
describe('Tests para el ... Componente', () => {
  let wrapper = null

  // Antes de cada test
  beforeEach(() => {
    // Creamos los mocks 

    // renderizamos el componente
    wrapper = shallowMount(App)
  })

  // Después de cada test
  afterEach(() => {
    jest.resetModules()
    jest.clearAllMocks()  // Si estás mockeando una librería
  })

  test('Caso de Test X', () => {
    // comprobamos el nombre del componente
    expect(wrapper.vm.$options.name).toMatch('...')

  })

  test('Caso de Test Y', () => {
    ...
  })

  ...
})

Code Coverage

Si quieres tener un informe de la cobertura de tu código (%) añade estas líneas a tu fichero jest.config.js:

collectCoverage: true,
collectCoverageFrom: [
  "src/**/*.{js,vue}",
  "!**/node_modules/**"
],
coverageReporters: [
  "html",
  "text-summary"
]

Cypress

Cypress es una de las muchas posibilidades que tenemos para testear nuestro código o proyecto en Vue.js para realizar pruebas E2E de manera automatizada con mucha potencia, y nos permite muchas posibilidades para analizar que interaccionamos correctamente con nuestro código resolviendo las historias de usuario a realizar.

Aserciones

Puedes consultarlas aquí. Pero se basan principalmente en Chai y Sinon.

Algunos métodos útiles de Cypress

• visit: redirige a Chrome a la URL que se le pasa por parámetro.
• get: obtiene un elemento por el identificador que le pasemos para realizar acciones sobre él. Como hemos explicado en el apartado anterior, todos los identificadores que pasemos serán obtenidos del CSS.
• children: nos permite obtener un elemento que pasamos por parámetro, que desciende del elemento que hemos obtenido con la función get.
• click: realiza un clic sobre el elemento que hayamos obtenido con la función get.
• type: escribe sobre el elemento obtenido un texto que pasamos por parámetro. Por ejemplo, usamos esta función para elementos input donde queremos introducir un texto.
• submit: permite enviar el contenido del formulario.
• contains: para indicar el contenido del elemento.
• have.attr: para indicar que el elemento tiene un atributo en concreto.
• include: para indicar que el atributo de un elemento incluye un texto.

A todas las funciones se les puede pasar un JSON con el elemento timeout. Este elemento nos permite incluir un tiempo que nos ayudará a esperar a que el elemento termine de cargar en la página.

Buenas prácticas

Es importante que tengamos buenas prácticas para testear sin problemas. Entre ellas, el manejo de selectores óptimos para nuestros elementos de la web, como pueden ser selectores de web del tipo con selectores del tipo id como son: data-testid (mi preferido para usarlo también con JEST) o data-cy.

Repositorio

Principios del TDD

Automatizar los test unitarios y poder trabajar con ellos nos ofrece iniciar las bases del TDD (Test-Driven Development). El desarrollo guiado por pruebas de software, o Test-driven development (TDD), es una práctica de ingeniería de software que involucra otras dos prácticas: escribir las pruebas primero (Test First Development) y refactorización (Refactoring). Para ello:

• Crea el test.
• Comprueba que falla.
• Escribe el código justo para pasarlo.
• Comprueba que funciona.
• Refactoriza.
• Vuelve al primer paso.
• Y disfrutar 🙂.

El propósito del desarrollo guiado por pruebas es lograr un código limpio que funcione. La idea es que los requisitos sean traducidos a pruebas; de este modo, cuando las pruebas pasen, se garantizará que el software cumple con los requisitos que se han establecido. Para ello debemos trabajar en requisitos o en partes de las historias de usuario.

ATDD (Acceptance Test Driven Development)

Los tests de aceptación o de cliente son el criterio escrito de que el software cumple los requisitos de negocio que el cliente demanda. Los requisitos se traducen por ejemplos ejecutables (de cómo se ejecuta una funcionalidad con sus entradas y salidas esperadas) surgidos del consenso entre los distintos miembros del equipo, incluido, por supuesto, el cliente. Una vez que tenemos los ATDD, se crea el test que lo representa y, posteriormente, iniciamos TDD; de esta manera, el código que pasa el test se asegura que cumple con el requisito a conseguir.

Jest

Jest es una de las muchas posibilidades que tenemos para testear nuestro código o proyecto en JavaScript (ya sea en cliente o en Node.js). Jest está basado en Jasmine, y se define como la suite de "test con 0 configuración"; es decir, mientras otras suites de test necesitan de un motor (test runner) para pasar los test y de la propia suite de test, así como de una librería de aserciones o matchers, Jest intenta que todo esto esté ya agrupado para agilizar el proceso de test desde el principio. Esto no quiere decir que no se pueda ampliar o profundizar y personalizar con otras librerías o que no tenga la potencia de otros.

En cualquier caso, las bases de estos ejemplos te servirán para las distintas alternativas existentes.

Otras alternativas

Existen muchas alternativas y cada una enfocada a un aspecto. En este tutorial me centro en Jest, pero como he dicho hay varias, ya sea para test unitarios, TDD, BDD o E2E. Te recomiendo este artículo para tener una visión al respecto. Remarco los siguientes para test unitarios:

• Jasmine. Es una de las librerías por excelencia para hacer test, "padre" de Jest y, además, la suite básica en Angular.
• Karma. Es un motor de test, desarrollado por el equipo de Angular, que suele usarse junto a Jasmine para este tipo de proyectos.
• Mocha. Es una librería de test pensada sobre todo para aplicaciones Node.js, muy potente y configurable al gusto.
• Chai. Es una librería de aserciones generalmente usada con Mocha para dar potencia a nuestros matchers en nuestros tests.

Instalación

Es importante seguir la documentación oficial.

npm install --save-dev jest

Otras configuraciones

Otras configuraciones realizadas las tienes en package.json.

Ejecutando el test

Debes tener un directorio llamado tests, y en él ficheros .spec.test.

npm run test

Matchers

Los Matchers nos permiten comparar de diferente manera valores esperados con los obtenidos. Podemos hacerlo de la siguiente manera, aunque hay más:

Igualdad

• .toBe: usado para comparar valores primitivos.
• .toEqual: usado para comparar recursivamente todas las propiedades de un objeto, también conocido como igualdad profunda.

Numéricos

• .toBeLessThan: el valor es menor que.
• .toBeLessThanOrEqual: el valor es menor o igual que.
• .toBeGreaterThanOrEqual: el valor es mayor o igual que.
• .toBeGreaterThan: el valor es mayor que.

Boolean, Nulos y Undefined

• .toBeTruthy: el valor es verdadero.
• .toBeFalsy: el valor es falso.
• .toBeUndefined: el valor es 'undefined'.
• .toBeNull: el valor es 'null'.

Arrays y contenido

• .toContain: contiene el elemento dentro del array.
• .toHaveLength: el array tiene la longitud.

Strings

• .toMatch: comprueba que un texto coincide con una expresión regular.
• .toHaveLength: comprueba la longitud.
• Podemos usar otros anteriores.

Cobertura

Podemos saber cuánto hemos testeado nuestro código realizando un análisis de cobertura. Jest nos ofrece el flag --coverage en la línea de comandos para comprobar la cobertura de nuestros test.

Informe de cobertura consola

npm run test:coverage

jest --coverage


 PASS  tests/funciones.spec.js

Introducción al Testing E2E

Los tests E2E (End to End) simulan el comportamiento de un usuario real. Prueban toda la aplicación de principio a fin, cubriendo así secciones que las pruebas unitarias y las pruebas de integración no cubren.

Aunque la pirámide de Cohn aconseja realizar más tests unitarios y de integración que tests E2E, ya que estos últimos pueden llegar a ser más frágiles y lentos, sabemos que son pruebas con mayor integración entre todas las partes de la aplicación y ejecutarán una gran parte del código de la aplicación.

El objetivo de estas pruebas es el mismo que cualquier otro tipo de prueba: la detección de errores. Pero la perspectiva E2E nos permite dar un paso más y, aparte de errores con una visibilidad más o menos inmediata, podremos determinar la existencia de indefiniciones funcionales o errores ocultos en base a las historias de usuarios.

Objetivos

En las pruebas E2E detectamos principalmente:

• Errores en la definición de la comunicación de dos sistemas: un sistema envía unos parámetros, pero el sistema con el que se comunica espera recibir otros y se genera un error.
• Ausencia de un sistema: no tenemos la versión actualizada de un sistema que forma parte del flujo de negocio a probar, o no se ha tenido en cuenta que ese sistema debe participar o debe modificarse.
• Error en la definición del funcionamiento del flujo funcional: todos los componentes y sistemas funcionan correctamente, hemos ejecutado la prueba de principio a fin sin errores, pero el resultado final es incoherente con el esperado. Esta es la gran potencia de las pruebas E2E: la detección de errores de definición, y la solución suele pasar por una redefinición del proceso.
• Que las historias de usuario se cumplen.

Debido a la importancia del usuario, es importante que estas pruebas se realicen teniendo en cuenta las historias de usuario para comprobar que los resultados tras la interacción cumplen los criterios de aceptación.

E2E en BDD/TDD

En definitiva, definimos funcionalidades y escenarios de uso que desarrollamos en distintos componentes y funciones que testeamos (test unitarios), integramos (integración) y, finalmente, comprobamos si todo el flujo sigue el escenario indicado desde el punto de vista del usuario.

Historias de usuario

Una historia de usuario es una explicación general e informal de una función de software escrita desde la perspectiva del usuario final. Su propósito es articular cómo proporcionará una función de software valor al cliente.

Las historias de usuario nos muestran los requisitos a conseguir, la interacción a realizar, los resultados esperados y cómo se realizará la aceptación de las mismas; es por ello que son nuestro principal "contrato" para nuestros test unitarios y sobre todo nuestros test E2E.

Beneficios

Las historias de usuario tienen varios beneficios clave:

• Las historias centran la atención en el usuario. Una lista de tareas pendientes mantiene al equipo centrado en tareas que deben completarse, pero un conjunto de historias lo mantiene centrado en solucionar problemas para usuarios reales.
• Las historias permiten la colaboración. Con el objetivo definido, el equipo puede colaborar para decidir cómo ofrecer un mejor servicio al usuario y cumplir con dicho objetivo.
• Las historias impulsan soluciones creativas. Las historias fomentan que el equipo piense de forma crítica y creativa sobre cómo lograr mejor un objetivo.
• Las historias motivan. Con cada historia, el equipo de desarrollo disfruta de un pequeño reto y una pequeña victoria, lo que aumenta la motivación.
• Son la base de nuestros test y nos aseguran que una vez cumplidas se cumplen los requisitos del software y sus criterios de aceptación.

¿Cómo usarlas?

• Describe tareas o subtareas: decide qué pasos específicos deben completarse y quién es responsable de cada uno de ellos.
• Perfiles de usuario: ¿para quién? Si hay varios usuarios finales, considera crear varias historias.
• Pasos ordenados: escribe una historia para cada paso en un proceso más grande.
• Escucha el feedback: habla con los usuarios y capta sus problemas y necesidades en lo que dicen. No es necesario tener que estar adivinando las historias cuando puedes obtenerlas de tus clientes.
• Tiempo: el tiempo es un tema delicado. Muchos equipos de desarrollo evitan hablar sobre el tiempo y, en su lugar, confían en sus marcos de trabajo de estimación. Dado que las historias deberían completarse en un sprint, aquellas que puedan necesitar semanas o meses deberían dividirse en historias más pequeñas o considerarse un epic independiente.

Plantilla y ejemplos de historias de usuario

Las historias de usuario suelen expresarse con una frase simple con la siguiente estructura:

"Como [perfil], [quiero] [para]".

Desglosemos esta estructura:

• "Como [perfil]": ¿para quién desarrollamos esto? No solo buscamos un puesto, buscamos el perfil de la persona. Max. Nuestro equipo debería comprender quién es Max. Con suerte, hemos entrevistado a muchos Max. Comprendemos cómo trabaja esa persona, cómo piensa y cómo se siente. Sentimos empatía por Max.
• "Quiere": aquí describimos su intención, no las funciones que usan. ¿Qué es lo que están intentando lograr realmente? Esta descripción debería realizarse con independencia de las implementaciones; si describes algún elemento de la IU y no el objetivo del usuario, estás cometiendo un error.
• "Para": ¿cómo encaja su deseo inmediato de hacer algo en la perspectiva general? ¿Cuál es el beneficio general que intentan lograr? ¿Cuál es el gran problema que debe resolverse?

Por ejemplo, las historias de usuario pueden tener este aspecto:

• Como Pepe, quiero invitar a mis amigos para que podamos disfrutar de este servicio juntos.
• Como Ana, quiero organizar mi trabajo para poder sentir que tengo un mayor control.
• Como gestor, quiero poder comprender el progreso de mis compañeros para poder informar sobre nuestros éxitos y fallos.

CYPRESS

Cypress es una de las muchas posibilidades que tenemos para testear nuestro código o proyecto en JavaScript/HTML para realizar pruebas E2E de manera automatizada con mucha potencia, y nos permite muchas posibilidades para analizar que interaccionamos con nuestro código resolviendo las historias de usuario a realizar. Debo remarcar que Cypress nos permite hacer pruebas de integración y de componentes en sus últimas versiones.

En cualquier caso, las bases de estos ejemplos te servirán para las distintas alternativas existentes.

Recuerda que Cypress.io es una herramienta de testeo de front-end de código abierto construida para la web moderna. Este framework "todo en uno" incluye librerías de aserciones, mocks y pruebas end-to-end automáticas sin utilizar Selenium. Como dice en su web: "Cypress prueba todo lo que se ejecuta en un navegador web". Esto no implica que te saltes los test unitarios 😉.

Otras alternativas

Existen muchas alternativas. En este tutorial me centro en Cypress, pero como he dicho hay varias, ya sea para test unitarios, TDD, BDD o E2E. Te recomiendo este artículo para tener una visión al respecto.

Instalación

Es importante seguir la documentación oficial.

npm install cypress --save-dev

Otras configuraciones

Otras configuraciones realizadas las tienes en package.json.

Ejecutando Cypress

Debes tener un directorio llamado tests y, en ellos, ficheros .spec.test.

./node_modules/.bin/cypress open

npm run cy:open

La carpeta Cypress

• Fixtures: datos estáticos que pueden ser utilizados para los tests.
• Integration: lugar donde colocaremos los tests. Por defecto contiene una carpeta de tests de ejemplo.
• Plugins: permiten acceder, modificar o ampliar el comportamiento interno de Cypress.
• Support: lugar para colocar comportamientos reutilizables, como comandos personalizados o anulaciones globales, que estarán disponibles para todos los tests.

Aserciones

Puedes consultarlas aquí. Pero se basan principalmente en Chai y Sinon.

Algunos métodos útiles de Cypress

• visit: redirige a Chrome a la URL que se le pasa por parámetro.
• get: obtiene un elemento por el identificador que le pasemos para realizar acciones sobre él. Como hemos explicado en el apartado anterior, todos los identificadores que pasemos serán obtenidos del CSS.
• children: nos permite obtener un elemento que pasamos por parámetro, que desciende del elemento que hemos obtenido con la función get.
• click: realiza un clic sobre el elemento que hayamos obtenido con la función get.
• type: escribe sobre el elemento obtenido un texto que pasamos por parámetro. Por ejemplo, usamos esta función para elementos input donde queremos introducir un texto.
• submit: permite enviar el contenido del formulario.
• contains: para indicar el contenido del elemento.
• have.attr: para indicar que el elemento tiene un atributo en concreto.
• include: para indicar que el atributo de un elemento incluye un texto.

A todas las funciones se les puede pasar un JSON con el elemento timeout. Este elemento nos permite incluir un tiempo que nos ayudará a esperar a que el elemento termine de cargar en la página.

Ejecutando los tests

El comando run ejecutará todos los tests que tengamos dentro de la carpeta Integration.

./node_modules/.bin/cypress run

npm run cy:run

Si el test falla

Si nuestro test fallase, podríamos ejecutarlo en modo headed para poder depurarlo más fácilmente.

./node_modules/.bin/cypress run --headed

npm run cy:run --headed

Buenas prácticas

Es importante que tengamos buenas prácticas para testear sin problemas. Entre ellas, el manejo de selectores óptimos para nuestros elementos de la web, como pueden ser selectores de web del tipo con selectores del tipo id como son: data-testid (mi preferido para usarlo también con JEST) o data-cy.

Ejemplos

En la carpeta Integrations/examples tienes muchos ejemplos para aprender todo de cómo usarlo. Aquí también puedes encontrar más información de cómo usarlo.

Testeando un framework: Vue.js

Nos centraremos en ejecutar el comando test:e2e para ejecutar nuestros test E2E con Cypress. Aunque, como he indicado, en las nuevas versiones de Cypress podemos testear aisladamente cada componente, así como conjuntamente.

Para ello crearemos el proyecto con Vue CLI, indicando en la configuración manual el uso de test E2E. Puedes verlo en el proyecto todoapp del repositorio indicado, una aplicación clonada del listado de ejemplos de Vue.js y que solo nos interesa para testear. Podríamos haber cogido cualquiera nuestra 😃. Un ejemplo completo más profundo lo tienes aquí.

Configurando Cypress con Vue CLI

? Please pick a preset: Manually select features
? Check the features needed for your project: Choose Vue version, Babel, Linter, Unit, E2E
? Choose a version of Vue.js that you want to start the project with 2.x
? Pick a linter / formatter config: Airbnb
? Pick additional lint features: Lint on save
? Pick a unit testing solution: Jest
? Pick an E2E testing solution: (Use arrow keys)
 ❯ Cypress (Chrome only) 
 Nightwatch (WebDriver-based) 
 WebdriverIO (DevTools/DevTools based)

Ejemplo para ejecutar los test:

npm run test:e2e

Iremos aplicando ATDD/TDD en test E2E. Puedes seguir el proyecto todoapp commit a commit, así como sucesivos tests que vayan surgiendo.

JavaScript

El mundo de JavaScript, mejor dicho, ECMAScript, es apasionante y cada día cambia y crece más, a veces incluso es mareante y crea algo de vértigo al ver la cantidad de tecnologías que están disponibles. Todo tiene sus cosas buenas y malas. Reconozco que algo cambió en mí desde la especificación de 2015 (ES6) de JavaScript para que actualmente sea uno de mis lenguajes de referencia unido a las diversas tecnologías que han crecido a su alrededor.

Yo, que me gustaba (y me gusta) el desarrollo móvil y el back-end, estaba algo hastiado por la pesadez de Java (en peso y rendimiento) para todas las cosas. No voy a negar que me encanta Spring Boot, pero le veía falta de agilidad; a la hora del escritorio, Swing no da para más. A nivel de móviles, menos mal que Kotlin ha venido a agilizar las cosas. También me aburría PHP en el back, pero no Laravel, el cual sigo encontrando elegante y una opción que siempre recomendaré.

Quizás sea el propio cambio, o la búsqueda de nuevos caminos y no dejar de aprender, lo que poco a poco hizo que el universo JavaScript me fuera atrapando. Esto me fue atrapando, no tanto por su potencia como lenguaje aislado para la web y el manejo del DOM, sino por la cantidad de tecnologías que han crecido a su alrededor que me han hecho sentirme tan cómodo, tanto como profesor como desarrollador, al poder centrar todos mis desarrollos con esta tecnología, lo que permitía no ir dando saltos de un lenguaje a otro. Quizás tecnológicamente no sea la mejor opción, pero me permite combinar distintos paradigmas: objetos, funcional, etc., para agilizar o aumentar la velocidad de desarrollo y con ello mostrar el mismo código desde distintas vertientes.

Node.js

Mi primera alegría fue poder ir del front al back con JavaScript. Node.js puede que no sea la mejor opción para todos los desarrollos back, pero sí que me ofrece a mí la simplicidad para poder realizar el back que necesito eficientemente. Sobre todo a la hora de hacer servicios o microservicios que trabajan como API REST.

Multiplataforma

La otra gran ventaja de usar el stack JS es poder usarlo en distintos desarrollos y distintas plataformas e independencia del sistema operativo. Desde aplicaciones back o de escritorio independientes del SO sin lidiar con Java-Swing o .NET gracias a Electron, web (obviamente), hasta aplicaciones móviles (NativeScript, Ionic) o incluso construir skills de Alexa. El mero hecho de no cambiar de lenguaje ya de por sí es una opción muy interesante que aporta comodidad y uniformidad a lo que hago. Repito: quizás no es la mejor opción, pero yo me siento bien, y muchas cosas las hago solo para mí 😀.

Web

JavaScript nació para "darle poderes" al desarrollo web y es su principal nicho. Gracias a ES2015 ganó mucho como lenguaje y sobre todo gracias a los frameworks existentes uno tiene opciones para aburrirse para poder desarrollar. En mi caso siento debilidad por Vue.js y su entorno 💘; dedicaré un día un especial completo a ello. Pero digamos que tengo toda la potencia para cubrir lo que necesito en cualquier tipo de aplicaciones web, ya sea con Vanilla JS, como con Vue.js, como usando otras alternativas derivadas como Nuxt.js, VuePress o usando otras librerías o frameworks como Ionic, NativeScript, Framework7, etc.

Tu API REST

Cuando creamos una API REST tenemos muchas tecnologías y opciones para poder realizarla con éxito. Hay tantas que dependerá de la naturaleza del problema cuál debas elegir. Ya sea con TypeScript o JavaScript sobre Node.js, debes pensar cómo y de qué manera estructurar tu código. Ya uses MongoDB, Amazon, MariaDB o Firebase, hacerte tu propio back te va a dar el control de cómo y de qué manera acceden a tus recursos desde cualquier dispositivo.

En esta entrada te mostraré distintas tecnologías y proyectos usados como ejemplos con el alumnado o a nivel personal donde se integran distintas opciones. Algunas, ya verás, se irán repitiendo en ellos como un patrón base a seguir.

Principales ideas

Adapta a tu problema

Divídela por capas; usa, por ejemplo, el patrón MVC, que en Node.js ofrece una arquitectura de fácil implementación y extensión de tu problema. Rutas 100% RESTful, usa los verbos HTTP para realizar todas tus operaciones. Patrón de operaciones CRUD sobre recursos: podrás añadir, listar, modificar o eliminar. Sube tus ficheros a tu servidor. Todo almacenado usando MongoDB.

Seguridad ante todo

JSON Web Token (abreviado JWT) es un estándar abierto basado en JSON propuesto por IETF (RFC 7519) para la creación de tokens de acceso que permiten la propagación de identidad y privilegios. Además, hemos implementado la opción de refresco de tokens para añadir más funcionalidad.

CI/CD

Compila, prueba, despliega. Solo haz clic. Mejora tu productividad aplicando integración y despliegue continuo (CI/CD). Usaremos GitHub Actions para crear un flujo de trabajo y compilar, realizar el análisis de código estático y ejecutar pruebas automáticas para la detección temprana de errores y, finalmente, el despliegue de todo el proyecto en Heroku y DockerHub.

La nube es tu amiga

No importa dónde estés. Yo estaré allí. No te limites a implementar en un solo lugar: usa la nube para un desarrollo continuo y descentralizado. Usa MongoDB Atlas, Firebase, Amazon AWS, GitHub como repositorio de código, pruebas unitarias automatizadas, Heroku y DockerHub para su despliegue. Si no tienes cliente, puedes usar Postman. Todo esto ayudará a mejorar tu productividad. No importa dónde estés, simplemente desarrolla tu API para que esté siempre disponible.

NodeMonREST

Ejemplo de API REST en Node.js, usando Mongo, JWT y AWS S3 con CI/CD bajo GitHub Actions para fines docentes.

Descripción

Este proyecto tiene nombre de Pokemon 😃. El objetivo principal docente es aplicar distintas técnicas para construir un esqueleto de API REST usable en distintos proyectos. La idea es hacer un esqueleto lo suficientemente genérico, adaptable y extensible en módulos para ser aplicado en distintos problemas y con él resolver cuestiones que se nos pueden presentar genéricas en cada uno de ellos, con el objetivo de mostrar para el ámbito docente cómo poder realizarlo. Es una aplicación puramente docente. Entre las distintas técnicas usadas destacan:

• Distribución de los elementos del sistema. Tenemos distribuidos en distintos nodos cada uno de los componentes cruciales del sistema: código, información y almacenamiento de ficheros.
• Patrón MVC. La vista será cualquier cliente que consuma nuestra API.
• Asincronía y respuesta a eventos. Uso de promesas e interacción basada en eventos, que es uno de los aspectos más fuertes de Node.js.
• Acceso a bases de datos NoSQL usando MongoDB.
• Autenticación y autorización usando JWT.
• Autorización basada en permisos de usuario.
• Manejo de CORS.
• Algunos patrones de diseño conocidos.
• JS código ECMA2019. De esta manera nos aseguramos seguir los estándares marcados para este tipo de lenguaje, pero tratando los módulos como indica Node.js, usando Babel para compatibilidad. Además, se ha aplicado el estilo AirBnB, uno de los más seguidos con el objetivo de mantener una filosofía de sintaxis y estilo de programación ampliamente seguida en la comunidad JS/Node.
• Almacenamiento en la nube usando AWS.
• Desarrollo CI/CD usando GitHub Actions.

Tecnologías y librerías usadas

• Node.js. JS en servidor.
• MongoDB. He usado su versión en la nube Atlas.
• Express. Framework de aplicaciones web para la API. Con él creo y gestiono las rutas. Además, nos permite fácilmente crear middlewares, con lo cual podremos aplicar logs específicos, filtrar para autorizaciones y autenticaciones y ampliar mediante middleware. Es lo que más me gusta de esta librería. Te recomiendo mirar el código de los ficheros route y middleware para ver cómo realizo estas acciones. Una de las cosas importantes es cómo he creado el servidor para que pueda ser levantado como instancia en cada una de las pruebas.
• Mongoose. Conjunto de librerías para operar con bases de datos MongoDB. He implementado el acceso usando singleton.
• JWT-Simple. Para implementar la autenticación basada en JWT. Esta librería actúa en base a middleware con Express. Los propios tokens caducan dependiendo del valor de .env TOKEN_LIFE en minutos. Para la parte de autorización, también hemos encapsulado en ellos los permisos de usuario que tengan. También hemos usado el refresco de tokens, en base a UUID almacenando los tokens de refresco en MongoDB con un índice TTL de la colección en base al valor de .env TOKEN_REFRESH en minutos. De esta manera se autodestruyen pasado ese tiempo y libera el token de refresco asociado al token de usuario, dando un poco de seguridad extra. El objetivo de implementar este tipo de token de refresco es que, si el access token tiene fecha de expiración, una vez que caduca el usuario tendría que autenticarse de nuevo para obtener un access token. Con el refresh token, este paso se puede saltar y con una petición a la API obtener un nuevo access token que permita al usuario seguir accediendo a los recursos de la aplicación hasta que el refresh token caduque. Se debe tener en cuenta que el TTL del token de autenticación debe ser menor que el de refresco.
• BCrypt. Librería de criptografía para manejar las contraseñas de los usuarios.
• Body Parser. Middleware que parsea los body como objetos (ya no se utiliza, pero cuando hice este proyecto sí; puedes mirar el ejemplo con TypeScript siguiente para ver otras opciones).
• Cors. Middleware para manejo de CORS.
• Dotenv. Para leer las variables de entorno del fichero .env.
• Morgan. Middleware Request logger el cual nos permitirá sacar logs de nuestras peticiones HTTP.
• UUID. Implementa el RFC4122 UUID para los tokens de refresco.
• Express-fileupload. Es un middleware para Express el cual nos ayuda a procesar peticiones multipart o subida de imágenes. Se ha puesto que el tamaño máximo por imagen sea 2 MB, aunque se puede cambiar en el fichero .env. Los directorios para almacenar imágenes o ficheros están en .env; puedes poner el mismo o lo que quieras, pues se crean dinámicamente dentro de public/uploads (FILES_PATH) y son accesibles directamente por la ruta url/files (FILES_URL). Puedes usar el mismo si quieres.
• AWS. Se ha implementado el sistema de almacenamiento en la nube para no depender localmente del servidor. Si quieres la versión en el servidor, revisa esta rama. La idea de usar este tipo de tecnologías es aprender a usar almacenamiento en la nube siguiendo la filosofía de distribución de cada uno de los elementos del sistema: código, bases de datos y ficheros.
• Joi. Nos sirve para validar los datos de entrada en base a un esquema de validación, por si no usamos la validación en los propios esquemas de Mongo. Es importante que el back valide todos los datos por si se ha escapado algo del front. No podemos dejar nada a la suerte. ¡Luke, somos la última esperanza!
• Mongoose-unique-validator. Nos sirve para validar los campos unique. Actúa como middleware.
• Underscore. Nos permite extender las posibilidades de la programación funcional para algunos métodos.
• Express-handlebars. Personalmente, uno de los mejores motores de plantillas para Node.js, basado en Handlebars. Lo he usado de ejemplo para hacer algunas páginas estáticas de presentación de la API.
• Mocha y Chai. Se han utilizado estas librerías para los test por su funcionalidad y porque se adaptan perfectamente al proceso de integración continua que se ha marcado como objetivo.
• Babel y ESLint con el objetivo de construir un código ampliamente compatible y estandarizado de JS.
• GitHub Actions. Es una de las grandes herramientas que se ha usado para la integración/distribución continuas CI/CD. Para ello hemos integrado el entorno de ejecución con pruebas y el despliegue como docker en DockerHub y su despliegue para su uso en Heroku.

Repositorio

Notas-Back-NEM

Este proyecto tiene como objetivo hacer la parte de backend por capas de una aplicación de notas para consumirla con distintos clientes usando las tecnologías de Node.js, MongoDB y Express, y está basada en el proyecto NodeMonREST. Como implementación de almacenamiento se ha utilizado Google Firebase Cloud Storage.

Repositorio

TypeScript API REST

Ejemplo de una API REST realizada con TypeScript. Autenticación, CRUD, transferencia de ficheros. Modos de trabajo en: memoria, MongoDB o MariaDB. Despliegue en Docker y test con Jest.

Descripción

El proyecto consiste en que tengas un ejemplo de API REST, pero realizada con TypeScript, con el objetivo de mejorar con tipos tus desarrollos. Además, propone el uso de ficheros, autenticación y autorización mediante JWT. Tiene tres modos de uso: memoria, con MongoDB (NoSQL) y MariaDB (SQL). Acceso desde: http://localhost:8000.

Arquitectura y diseño

El diseño de esta API REST se corresponde con el patrón Servidor->Enrutador->Controlador->Modelo. El servidor escucha en un puerto diversas peticiones. Las procesa según su ruta o punto de entrada y se las pasa al enrutador. El enrutador analiza la petición dependiendo de la ruta y se la pasa al controlador correspondiente a dicha ruta, que ejecutará el método indicado. El controlador realiza el método indicado según la ruta, consultando los modelos y el almacenamiento para ello. El modelo es la estructuración de los datos a tratar.

En todo momento se ofrece información de la petición en base a los códigos de estado HTTP.

Modos de funcionamiento

Este proyecto está basado en dos modos de funcionamiento en la URL: http://localhost:8000.

• Memoria: usando almacenamiento en memoria. Lo tienes en la rama memoria.
• MongoDB: usando almacenamiento en MongoDB. Lo tienes en la rama MongoDB.
• MariaDB: usando almacenamiento en MariaDB. Lo tienes en la rama MariaDB.

Autenticación y autorización: JWT y middleware

Se ha implementado un sistema de autenticación y autorización basado en JWT y aplicando un middleware para analizar si el usuario puede entrar a un recurso, ya sea porque está autenticado para ello (auth), tiene permisos dependiendo de su rol (grant) o dicho recurso le pertenece si tenemos datos que los relacionan (owner). Se ha jugado con distintas políticas dependiendo del recurso y se puede adaptar a las distintas necesidades del problema. En el código podrás ver distintas soluciones con middleware o dentro del controlador.

Validadores de datos

Se han implementado dos sistemas de validación de campos según los requisitos de los tipos de datos. Por un lado, un middleware de validación y por otro, si no queremos hacerlo de esta manera, con funciones auxiliares en el propio controlador.

Endpoints

Los endpoints para conectarse y consumir esta API REST empiezan siempre por /api/vx/recurso, donde x es la versión de esta API y recurso es el recurso a consumir, por ejemplo /api/v1/juegos desde http://localhost:8000.

| Método | Recurso | Auten./Autor. | Descripción | |

GitHub Campus Advisor

A día de hoy, considero fundamentales las tecnologías de GitHub y su paquete educativo. Ahora me han nombrado GitHub Campus Advisor. Me encanta la idea de poder ayudar a profesorado y alumnado a desarrollar nuestro código usando GitHub. A la misma vez, me hace sentir muy feliz por mi centro, compañeros/as y alumnado, que se beneficiarán de ello, así como por cualquier persona que necesite mi ayuda. Y, sobre todo, me ilusiona poder ayudar y responder dudas que la comunidad me haga. Es un honor que GitHub confíe en mí para ello.

¿Qué haré?

Seguiré con mi rutina diaria, pues ya hemos demostrado en cursos como DAW que integrar GitHub en todo el proceso de enseñanza-aprendizaje es posible en todos los módulos de segundo. Podéis ver la experiencia en nuestros proyectos de innovación.

Mostraré y aplicaré mi experiencia docente y como desarrollador aplicando las tecnologías de GitHub en mis módulos, tutoriales y proyectos. Fomentaré el uso en la comunidad educativa y seré soporte de quien lo necesite. Así que, si os interesa el material o simplemente os puedo ayudar en algo, no dudéis en contactar conmigo. Será un placer poder echaros un cable con ello. ¡Cuenta conmigo! 💪

Se vienen cosas muy interesantes en el futuro y, con GitHub, desarrollar y aprender será mucho más fácil.