DEV Community: Ale Sánchez

In a stupid defence of human-crafted content

Ale Sánchez — Thu, 04 Sep 2025 18:57:07 +0000

Recently, I stumbled upon this image from Marketoonist:

And it hit me differently. I came to the realisation that we should defend human-crafted content, even though it may feel stupid.

So, from now on, I'll try to write concise, to-the-point posts as part of my (rather futile) battle against AI slop.

Presenting Assistant Language. A programming language created with GPT3

Ale Sánchez — Sun, 04 Dec 2022 14:23:31 +0000

Ok, so you probably heard aboutOpenAI's chatbot. It's the most advanced chatbot created so far. It can help people with LaTeX questions, find bugs in code or solve code challenges.

What I tried for this post is something different. I instructed ChatGPT to create a programming language for me and become the interpreter for that programming language.

I took the idea and a few useful instructions from this blog post.

Let's start simple

I started instructing the bot to create a simple language with an instruction to print. Also, it has to act as the interpreter of that language. To keep communicating with the bot I added a special format with slashes and quotes. Here's the result:

If you want to use my prompt, here it is

I want you to create a new programming language. It has to provide only an instruction for printing something to screen. I want you to explain to me how to use it in a concise way. After that, you will become an interpreter of that language. Answer with the execution result inside one unique code block, and nothing else. Only write explanations if the code contains errors. When I need to tell you something in English, I will put text inside forward slashes and double quotes /"like this"/.

Ok, looks good so far. Let's try the interpreter.

It looks like it worked!

Adding functionality to the programming language

Let's try to add some more functionality to our new programming language.

Variables

Ok, using the slashes and quotes format I'll try to add variables to the programming language.

Again, looks promising, let's try the interpreter.

Arithmetic operators

Now, the same thing but with arithmetic operators.

Now that we know how to use it, let's try it:

Logic operators

Now, I'll try to add logic operators to the language, but without instructing first about data types or anything else:

I haven't talked about conditionals or flow control structures, but it added the ternary operator when asked to include logic operators. It may mean that GPT already "knows" the language, just telling me how to use every piece of it when I ask.

Let's try these new operators:

If statement

I don't want to bias the bot so I won't ask it to add if structure. Instead, I'll ask for a flow control structure for branching based on condition:

Well... exactly what I had in mind... Testing time!

Comparison operators

I almost forgot about a crucial part of a programming language, the comparison operators!! Let's add them to our language.

Ok, now let's see how it behaves:

Looping

Again, for not biasing the bot, I'll ask for structures to loop or iterate.

Ok, so it added a classic for loop as well as a while loop...

Hmmm... and what if I try to run an infinite loop?

It detects it and prevents me from running it!

Functions

The next step is to add functions to our new programming language.

Wow, we also can return multiple values and unpack them...

Utility functions

Let's see if we can create some "global" utility functions to make our life easier.

Let's try to generate some random numbers:

And if we try to add a function to get the current date?

Let's do a little test:

So GPT knows which day it is, but not which time. Interesting.

Interact with the underlying OS

It already warns me about the shell function but, of course, I'll try to mess up to see if we can figure out something.

For the first time, it included an explanation along with the output, even though there are no errors. Also, the waning message is there again.

Let's keep testing.

For some reason, it explains the command instead of executing it. Maybe because it knows that the output won't be the same every time?

Did it really create the file? Or is it just "assuming" what would happen...

Apparently, it created it... Let's do another test for getting the contents of the root directory.

Hmmm, is the same output as the previous example but with the test dir...

Nope, it doesn't exist...

Ok, enough messing with the underlying OS.

Some advanced features

Would GPT be able to add pointers to our language?

So... we have pointers now!

Naming the language

Nice, I like Assistant Language, let's use it!

Would it be able to implement something in this language?

Not the most efficient version, but definitely in Assistant Language. Let's test it:

It actually works!

Wrap it up and provide an interpreter

I want the bot to generate a document with the language specification as well as an interpreter implemented, for example, in Python. Let's try!

You can see the full README here.

And finally... the interpreter.

It implemented an interpreter that supports only "let" and "print" statements... Let's see if I can get something more complete.

This looks way better! We don't have pointers, but it seems that everything else is supported.

You have all the code available here.

I hope more people try something like this and see how far it can get in adding functionality to the language!

¿Qué son y cómo funcionan las impresoras 3D?

Ale Sánchez — Sun, 18 Sep 2022 08:31:05 +0000

Si prefieres en vídeo, aquí te lo dejo:

Y si lo prefieres en podcast:

Tema interesante hoy la verdad. Vamos a hablar un poquito de qué son las impresoras 3D, cómo funcionan y qué tipos.

También veremos qué ventajas tiene cada una y qué se puede hacer con ellas.

Impresoras de tinta

Para empezar a hablar de ese tema vamos a remontarnos un poquito atrás. Concretamente a ver cómo funcionan las impresoras 2D de tinta de toda la vida.

Vamos a centrarnos en las de inyección de tinta porque las de láser funcionan un poquito diferente y no nos va a servir para nada a la hora de hablar de las 3D. Sin embargo las de inyección de tinta sí que nos van a servir.

Estas lo que tienen es un cabezal con la tinta. Este cabezal se va moviendo y la impresora sabe en qué punto del papel tiene que haber tinta. Concretamente porque en el documento o en la imagen, ese píxel no es blanco. Este cabezal se va moviendo y cuando pasa por uno de esos puntos del papel, echa tinta del color que corresponda. O bien negra, o bien sea mezclando colores para sacar el que debe echar.

Si alguna vez alguien ha visto una impresora de estas domésticas en funcionamiento, si mirabas un poquito se podía ver cómo funcionaba. Se podía ver cabezal pasando de izquierda a derecha, luego a la la izquierda otra vez, luego a la derecha... haciendo pasadas en cada. Cuando acaba con una línea lo que hace es moverse un poquito hacia abajo y vuelve a pasar por la siguiente. De nuevo, donde tiene que haber tinta, suelta tinta y, donde no tiene que haber tinta, no suelta nada (bastante evidente). Gracias a que el espacio que hay entre cada saltito de una línea a la siguiente es muy pequeño, puede imprimir con una muy buena resolución. Imagina si el tamaño fuese de dos dedos de salto, no podría imprimir nada con una resolución mayor a dos dedos.

Impresoras 3D

Para poder imprimir algo en 3D se necesita una cosa que se llama un modelo. Esto no es más que una representación en tres dimensiones del objeto que se quiere imprimir.

Cuando en una película de animación o algo similar ves un mueble o una casa o incluso un personaje, estás viendo modelos 3D. Pero claro, tú haces este modelo en 3D y se lo mandas a la impresora, pero ella no tiene el concepto este de tres dimensiones, no sabe interpretar esas profundidades, qué está delante o qué está detrás... la solución a esto es basarse en lo que hace una impresora 2D.

Sabemos que podemos imprimir en un papel en dos dimensiones, y tenemos un modelo que es de tres dimensiones. Es tan sencillo como convertir esas tres dimensiones en dos. ¿Cómo, tes estarás preguntando? Pues para no perder la tridimensionalidad, se parte del modelo 3D y, por ejemplo, de abajo hacia arriba lo va cortando en muchas capas muy finitas. Si luego colocas todas esas capas una encima de la otra, vuelves a tener tu modelo en 3D.

Impresoras de filamento

Esta impresoras usan para imprimir un filamento. Puede ser de muchos materiales pero vamos a asumir, por simplificar mucho, que es un filamento de plástico, así no nos complicamos la vida.

La impresora tiene un extrusor por el que pasa el filamento, este extrusor se calienta y hace que el filamento se derrita y se pueda usar como una especie de "tinta" para imprimir. Podemos pensar en el extrusor como si fuese los inyectores de tinta de la impresora 2D.

Como tenemos el modelo en 3D cortado en muchas capas (asumamos que de abajo hacia arriba), lo que va a hacer la impresora es coger esta primera capa, la más baja, y va a ir moviendo el cabezal y poniendo filamento derretido en cada punto de esa capa en la que tenga que haber material. Una vez que ha terminado de hacer esa capa, el extrusor sube un poquito, una mijita muy chica muy chica y pasa a la siguiente capa cortada encima de la anterior. Vuelve a colocar el filamento derretido donde corresponda en esta nueva capa y esto se va repitiendo capa a capa. Al final de este proceso, se habrá construido la figura en 3d que modelamos al principio.

Impresora 3D de filamento imprimiendo el modelo de una mano

Impresoras de Resina

La base es la misma, se coge el modelo en 3d y se corta en muchas capas. A diferencia de las de filamento, que tienen un extrusor que va derritiendo el filamento, aquí lo que se usa es resina líquida. En este caso la impresora es como una caja cerrada en la que se echa la resina resina. Por las características del material de la impresora y de la resina, esta no se pega a ninguna parte, únicamente a una plataforma móvil en la que se irá construyendo la figura.

Esta plataforma se baja hasta la resina para impregnarla de una capa muy fina. Para endurecer la resina, la impresora tiene un láser de luz ultravioleta. De nuevo, por las características químicas de la resina, cuando la luz ultravioleta incide en ella, se endurece. La impresora solo tiene que apunar con el laser a aquellos puntos donde, en el modelo, hay material y disparar luz UV con el láser. Al terminar con esa capa, vuelve a mojar la plataforma en una capa muy finita de resina (aunque aquí lo importante es que se moja el material endurecido de la capa anterior), y el láser ultravioleta vuelve a tocar donde corresponde en la segunda capa. Al igual que en la de filamento, esto se va repitiendo una y otra vez hasta que se tiene la figura completa impresa.

Impresora de resina

Aplicaciones

Es muy fácil de diferenciar las figuras que se imprimen con filamento de las que se imprimen con resina. Las de filamentos son muy características porque ves las líneas que ha ido dejando al secarse. Esto se debe a que el filamento se va poniendo en líneas, por así decirlo. En la de resina, por el contrario, se ve como una pieza única, un único bloque de plástico.

Figura de resina vs figura de filamento

En la imagen se aprecia claramente lo que quiero decir. La figura de filamento tiene mucho menos detalle y se ven las marcas horizontales.

Las impresoras de filamento suelen ser más baratas y son muy útiles para imprimir piezas o modelos que no son de exposición somo tal, sino que los quieres para resolver algún problema, como podría ser un engranaje roto de algún aparato, cuñas para las puertas, etc.

Para terminar, vamos a ver algunas cosas que se han impreso con impresoras 3D. Por supuesto no ha sido usando plástico, sino combinando muchos materiales, alguno de ellos orgánicos.

Comida
Piel
El taladro funcional en miniatura más pequeño
A partir de ecografías en 3D se puede imprimir el bebé que llevas dentro antes de que nazca. Esto se hace que los padres puedan cogerlo y verlo.
¡¡Edificios!!

Y, antes de terminar, si estás buscando comprarte una impresora de este tipo, te dejo una buena comparativa relación calidad-precio aquí.

La verdad es que es una pasada. Hasta aquí hemos llegado y la verdad es que espero que te haya gustado, que lo hayas disfrutado y que, por supuesto, haya sido útil y divertido.

Como siempre cualquier comentario, duda o sugerencia que tenga la puedes dejar en un comentario. ¡Hasta la próxima!

Concurrency or Parallelism? Differentiate them

Ale Sánchez — Thu, 01 Sep 2022 20:54:26 +0000

In this post, I'll try to illustrate the differences between concurrency and parallelism. These terms are usually misused (I did too several times), so let's see if we can finally clear any doubts about this topic.

What is a CPU and how does it work?

A CPU is like the brain of a computer. It's where the majority of the operations are done. Also is responsible for executing the tasks we need.

A CPU can have a single core or multiple cores. Let's imagine that a CPU is a factory, and each core is a worker. The more cores a CPU has, the more work it can perform at the same time.

This is the key part. Each core can perform only one task at a time. If this point is clear, you already understood half of the topic.

So... what is parallelism?

As the word says, it's when multiple tasks are run in parallel. That means that several tasks are run at the same time. If you understood the previous point... how many cores are needed (at minimum) if you want to run two tasks in parallel?

Since one core can perform only one task at a time, you'll need at least 2 cores. If you have more than two, the rest of the cores are going to be idle, because 1 task -> 1 core.

Ok, but what is concurrency?

Nice! We understood parallelism, let's dive into concurrency now!

You can think about concurrency as an illusion of parallelism. Let me explain that.

Imagine someone working in customer service. That person has to serve two queues of people, but there is only one employee. So the person decides to go with the first customer in the first queue. If that customer has to fill out a form or perform any other task that doesn't need the attention of the employee, the person goes to the second queue. If the same situation happens or the client in the first queue finishes the task, the employee comes back. Repeating that process creates an illusion of parallelism. As seen from the outside, it may look like the employee is serving both queues at the same time.

The same thing happens in a CPU. Since we are working with a single core, just one task at a time can be performed. But the CPU, by fast switching between the two tasks, creates an illusion of parallelism.

Conclusion

You have learned the differences between parallelism and concurrency. You learned that one core can work on just one task at the same time. If you want to run two tasks in parallel, you need a CPU with (at least) two cores. If your CPU is a single core and want to run two tasks at (almost) the same time, you need to use concurrency. In concurrency, the CPU switches very fast between the two tasks, creating an illusion of parallelism.

Depurar Python como un Pro

Ale Sánchez — Mon, 26 Jul 2021 17:53:32 +0000

Seguimos con la serie de posts sobre Python. Sigo con el bootcamp de Data Science y Machine Learning de Core Code School y en los últimos días hemos estado viendo cómo hacer visualizaciones de datos tremendamente molonas con Streamlit.

Durante el proceso de creación de la aplicación web con Streamlit nos encontramos con un problema que impedía ver los datos. Mientras que itentábamos ver la causa salió a colación el tema de la depuración de código y algunos compañeros no sabían lo que era.

Así que he visto una oportunidad magnífica de explicar lo que es la depuración de código, por qué es útil y cómo hacerlo en las herramientas que usamos de manera más usual en Core.

Qué es depurar

Lo primero y más importante es explicar y entender qué es eso de depurar el código o depurar un bug. También se suele decir mucho hacer Debug del código, hacer Debugging o, en una españolización del término, también puedes escuchar alguna vez Debuggear.

Básicamente, depurar es recorrer exhaustivamente un código para identificar y corregir la causa de un problema.

Este proceso tiene una parte muy fuerte de observación y otra parte creativa. Normalmente cuando vas depurando no sabes dónde está el fallo y por eso tiene que ir probando y recorriendo todo. Mientras vas depurando, tienes que ir viendo cómo cambian tus variables hasta que veas cuándo se produce el comportamiento anormal o que quieres resolver.

Para hacer todo esto, tienes muchas herramientas que te ayudan con el proceso.

Por qué necesito depurar

La realidad es que no siempre necesitas depurar, pero alguna vez lo necesitarás sin ninguna duda y, cuando eso pase, mejor tener las herramientas y los conocimientos.

Un método de depuración muy habitual es imprimir mensajes informativos para ver por dónde va pasando el código y qué valores van tomando las variables. Un ejemplo de esto es:

Ahí ves que hay un print para ver el parámetro que se le pasa a la función, es algo muy sencillo y pequeño pero ilustra lo que quiero decir.

Ejemplos de depuración

Ahora voy ponerte un ejemplo de lo que es depurar en tiempo real, lo que se ve y lo que se puede hacer.

En ese código tengo una lista de frases típicas. Lo que hago es un for que recorra la lista y le aplique un cifrado césar a cada una.

Como puedes ver, a la izquierda de la pantalla está lo que se llama el "inspector", en el que tienes acceso a cada variable y al valor que toma en cada momento.

Para que el depurador se pare en una línea concreta de tu código tienes que poner lo que se llama un punto de interrupción (en inglés, breakpoint). Esto se hace poniendo el ratón a la izquierda de los números de línea y clicando donde aparece un puntito rojo.

Ese punto está sombreado porque no está puesto, cuando clicas ahí se pone en un rojo más intenso y ya significa que está puesto:

Además, cuando la depuración llega a una función, puedes entrar dentro de ella y depurar esa función paso a paso, como he hecho en el vídeo.

Incluso en el bucle que hay en la función que hace el cifrado puedes ir letra a letra y ver cómo va calculando el resultado.

Con este método podrías detectar un bug en tu código y solucionarlo de manera más o menos sencilla.

Una vez que sabes qué es depurar, te voy a enseñar cómo hacerlo en las herramientas habituales que usamos en Core.

Depurar en VSCode

La primera de todas es, cómo no, Visual Studio Code. También es la más sencilla de las que vas a ver en el post.

Si te fijas en la barra izquierda de VSCode, puedes ver que hay un botón que es un signo de Play con un insecto encima (en inglés, un bug):

Púlsalo y te mostrará la vista de depuración. VSCode controla las configuraciones de depuración con un archivo que se llama launch.json y que se encuentra en la carpeta .vscode de tu proyecto.

Si es la primera vez que abres la vista de depuración y no tienes ninguna configuración, verás una vista como esta:

Lo que harás será pulsar donde dice "cree un archivo launch.json". Lo importante es que pulses eso mientras tienes un archivo .py abierto, porque así VSCode te sugerirá configuraciones para depurar en Python, como ves aquí:

Como ves, VSCode tiene configuraciones predefinidas para varias opciones de Python como depurar un archivo, un módulo o frameworks como Django, Flask o FastApi.

En este primer ejemplo vas a elegir Python File. Cuando lo selecciones, te creará un archivo launch.json dentro de la carpeta .vscode con el siguiente contenido:

{
  // Use IntelliSense para saber los atributos posibles.
  // Mantenga el puntero para ver las descripciones de los existentes atributos.
  // Para más información, visite: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Python: Archivo actual",
      "type": "python",
      "request": "launch",
      "program": "${file}",
      "console": "integratedTerminal"
    }
  ]
}

Una vez que ese archivo está guardado, puedes volver a la vista de depuración y verás que te aparece una vista distinta a la de antes con una opción con el mismo nombre que aparece en el atributo name de ese JSON.

Si te sigue apareciendo la misma vista que antes para crear un archivo launch.json, cierra y abre VSCode para que aplique los cambios.

Una vez tienes esto configurado y algún punto de ruptura puesto, ya puedes darle al play verde que aparece en la vista de depuración, a la izquierda del nombre de la configuración:

Eso deberá lanzarte la depuración y pararse en el primer punto de ruptura que se encuentre mientras ejecuta el código.

Una vez parado, te aparecerán los llamados controles de depuración que te voy a detallar ahora:

Seguir hasta el siguiente punto de interrupción. Reanuda la ejecución hasta que encuentre otro punto de ruptura. Ten en cuenta que si el punto está dentro de un bucle y le das al botón 1, se parará en ese mismo punto, pero en la siguiente vuelta del bucle.
Saltar a la siguiente instrucción, omitiendo procedimientos. Ejecuta la instrucción en la que está parado el depurador actualmente y pasa la siguiente. Ten en cuenta que ejecutar una instrucción implica que se pueden actualizar variables, mantén siempre un ojo en la parte de inspección de variables (barra izquierda).
Saltar a la siguiente instrucción, sin omitir procedimientos. Esto hace exactamente lo mismo que el botón anterior, salvo que salta a la siguiente instrucción inmediatamente. Puede parecer lo mismo, pero hay una diferencia. Si estás en una línea que ejecuta una función, el botón anterior no va a entrar dentro de la función, sino que va a omitirla (omitir el procedimiento) y saltará a la siguiente. Este botón entrará dentro. Aquí puedes ver la diferencia:
Sale de la función que estás depurando. Es útil si entras en una función creyendo que puede estar el problema ahí y cuando vas por la mitad ves que no está ahí, en vez de poner otro punto de ruptura o empezar de nuevo, simplemente sales de esa función y sigues adelante. Si estás en un código que no está dentro de ninguna función y sales, la depuración continuará hasta el siguiente punto de interrupción, como si hubieras dado al botón 1.
Reinicia el proceso de depuración. Lo mismo que parar y volver a empezar.
Para el proceso de depuración. Para la ejecución sin ejecutar nada más, no termina el proceso de manera normal, sino que corta la ejecución.

Consejo de Pro: Explora la pestaña "Consola de Depuración". Cuando estás parado en un punto de ruptura, puedes ejecutar código Python desde ahí y ver el resultado inmediatamente. Puedes anticiparte a errores o bugs.

Depurar en Jupyter

Ahora que sabes depurar en VSCode, vamos a probar con Jupyter. Lo cierto es que Jupyter Notebook no permite hacer depuración pero Jupyter Lab sí.

Para instalarlo puedes seguir las instrucciones oficiales. Lo puedes instalar con Conda sin problema.

Una vez instalado, hay que poner un par de paquetes de python y alguna extensión de Jupyter Lab.

Lo primero que vas a instalar es un kernel de Python compatible con la depuración, en este caso Xeus. Para instalarlo, ejecuta en una terminal:

conda install -c conda-forge xeus

Una vez está, puedes instalar la extensión de depuración, para esto ejecuta en una terminal:

jupyter labextension install @jupyterlab/debugger
jupyter lab build

Una vez instalada la extensión y terminado el build, ejecuta Jupyter lab con el comando:

jupyter lab

Una vez lanzado Jupyter, abre el notebook que quieras depurar. Ahora tienes que cambiar el kernel de python al que hemos instalado, XPython. Esto lo puedes cambiar en el selector de la esquina superior derecha.

Cuando cliques, debes ver una ventana para seleccionar el kernel que quieres, elige XPython:

Ahora verás que hay 2 cosas nuevas, relacionadas con la depuración:

Lo primero es un interruptor al lado de un icono de un insecto, y lo segundo es un botón con el mismo icono del insecto. Primero activa el interruptor, eso mostrará una barra para poner puntos de interrupción y además mostrará una barra a la izquierda con información similar a la que teníamos en VSCode.

Puedes poner puntos de ruptura de la misma manera que en VSCode, clicando a la izquierda del número de línea:

Una vez tienes el punto de ruptura, puedes ejecutar la celda de manera normal, y se parará en el punto:

A la izquierda tienes lo mismo que había en VSCode, el inspector de variables, los mismos botones para controlar la depuración y una lista de los puntos de ruptura.

Si pulsas el botón para ejecutar la instrucción entrando en funciones y la función está en otra celda, Jupyter se encargará de que salte a la celda correcta y siga la depuración normal.

Depurar Streamlit

Otra herramienta que usamos en Core es Streamlit. Como también puede haber errores al desarrollar una app de Streamlit, vas a aprender a depurar eso también.

Lo único que hace falta es una configuración nueva para nuestro launch.json.

Si lo abres, verás que la propiedad configurations es un array. Ahí puedes poner todas las configuraciones que quieras. Ya debes tener una, así que añade esta:

{
      "name": "Python: Streamlit",
      "type": "python",
      "request": "launch",
      "module": "streamlit.cli",
      "args": [
        "run",
        "${file}",
      ],
}

El nombre de esa configuración será Python: Streamlit, decimos que la depuración es python y que vamos a lanzar algo. En vez de lanzar un archivo como antes, ahora lo que vamos a lanzar es un módulo, en este caso stramlit.cli, que básicamente es el intérprete de comandos de Streamlit. Y, por último, vamos a pasarle al cli los argumentos run ${file}.

VSCode sustituirá ${file} por el archivo que tengas abierto al lanzar esa depuración. Si no quieres que sea así y siempre quieres que lance el mismo archivo, puedes sustituir eso por el archivo que necesites.

Esa configuración es equivalente a llamar a streamlit run ${file}.

Ahora solo tendrás que poner tus puntos de interrupción y lanzar la depuración.

Depurar Flask

Depurar Flask es igual de sencillo que Streamlit. Solo necesitas añadir una configuración de depuración al launch.json y listo.

En este caso, tienes que añadir:

{
    "name": "Python: Flask",
    "type": "python",
    "request": "launch",
    "module": "flask",
    "env": {
        "FLASK_APP": "app.py",
        "FLASK_ENV": "development",
        "FLASK_DEBUG": "0"
    },
    "args": [
        "run",
        "--no-debugger",
        "--no-reload"
    ],
    "jinja": true
},

Ahí lo que le dices es que la configuración se llama Python: Flask, que es de tipo python y que quieres lanzar un módulo, que es flask.

Con env se ponen una serie de variables de entorno que le indican a flask qué archivo tiene que ejecutar, en qué entorno está y desactiva el modo de depuración (porque ya lo gestiona VSCode).

Además, igual que antes, añade una serie de argumentos al comando flask para configurar la ejecución y añade un parámetro jinja que es el motor de plantillas que usa Flask, para permitir depurar eso también.

Si tú no vas a usar plantillas, puedes eliminar esa opción.

De nuevo, una vez tienes eso, solo necesitas activar tus puntos de ruptura y ejecutar la depuración.

Conclusiones

Ahora sabes lo que es depurar, por qué es importante y cómo hacerlo en algunas herramientas habituales en el desarrollo y en Python, ya no hay quien te pare.

Recuerda dejar en los comentarios cualquier duda o sugerencia que tengas y mirar los cursos de Core.

Nos vemos en el próximo post!

6 Cositas sabrosas que hacer con Python

Ale Sánchez — Thu, 15 Jul 2021 16:10:31 +0000

Como ya sabes por mis posts anteriores, llevo ya un par de meses embarcado en un Bootcamp de Machine Learning y Data Science con las buenas gentes de Core School.

Como es natural, el lenguaje principal es Python. Precisamente por eso, vengo con un magnífico post de 6 cosas magníficas que debes saber de Python!

1. Intercambia valores de variables en una sola sentencia

Esto viene directamente de la posibilidad de hacer una asignación múltiple a partir de una tupla. Mira, por ejemplo, este código

Como ves, puedes asignar las 2 variables a la vez teniendo una tupla. Si la tupla que usas para asignar las variables contiene, a su vez, otra dos variables, debe ser igual de válido.

Siguiendo la misma lógica, puedes usar las dos variables que quieres intercambiar dentro de la tupla, en orden inverso.

Y, por último, como en Python puedes omitir los paréntesis al crear una tupla, puedes dejarlo mucho más bonito (todos los pasos en el código).

2. Conoce y usa las funciones built-in

¿Por qué es importante? Porque esas funciones de Python están escritas directamente en C. Si tú implementas esas funciones a mano, tendrán que interpretarse en código Python, lo cual es más lento.

Aquí tienes todas las funciones built-in de Python. Un resumen de ellas:

3. Usa `in` para buscar en listas

Esto va muy de la mano del punto anterior. En lugar de usar find o de implementar tu propia función de búsqueda, usa in siempre que quieras comprobar si un elemento está en una lista. Es muy idiomático y limpio.

>>> 1 in [1, 2, 3]
True

4. Haz buenas migas con los list comprehensions

Esta es otra herramienta muy característica de Python. La base de esto es construir listas de una manera muy cómoda. La sintaxis básica es:

[variable for variable in lista]

Si quieres usar un condicional, puedes hacerlo.

[variable for variable in lista if condicion]

Y si quieres un if-else

[variable if condicion else otro_valor for variable in lista]

Ahora toca ver unos cuantos ejemplos.

5. Usa funciones generadoras para ahorrar memoria

El ejemplo más clásico de las funciones generadoras es range. No es lo mismo tener una función que te dice cómo generar 1000 valores, que tener 1000 valores guardados. La prueba:

>>> sys.getsizeof(range(1000))
48
>>> sys.getsizeof(list(range(1000)))
8056

En la primera línea lo que hay es un objeto que genera 1000 números bajo demanda, pesa 48 bytes. Sin embargo, la segunda línea lo que tiene es una lista con esos 1000 números en memoria, pesando 8 Kb.

Tú puedes hacer funciones generadoras usando la palabra yield. Te voy a poner un ejemplo muy tonto pero ilustrativo.

NOTA: Cuando tienes un generador (excepto con range), no puedes hacer generador[10], pues no está todo el conjunto de elementos en memoria, pero sí que puedes iterarlo con un for o list comprehension.

6. Python 3.8 o más: Operador walrus

A partir de la versión 3.8 Python tiene un operador que es este := y se llama el operador "morsa" (porque parece una morsa tumbada de lado).

Este operador te permite hacer una asignación dentro de otra expresión. Ejemplo

numero = 2

if (potencia := numero**2) > 3:
  print(potencia)

Ese código va a imprimir 4, porque se está haciendo la asignación de la variable potencia dentro de la misma expresión del if.

Otro ejemplo:

while (user_input := input("Escribe 'exit' para salir")) != "exit":
    print(user_input)

Ese bucle while se va a ejecutar eternamente hasta que el usuario escriba exit pero, además, tendrás acceso a lo que escriba el usuario en la variable user_input.

Recapitulación

Básicamente lo que has aprendido es que debes o puedes:

Intercambiar valores de variables en una sola sentencia
Conocer y usa las funciones built-in
Usar in para buscar en listas
Llevarte bien con los list comprehensions
Usar funciones generadoras para ahorrar memoria
Si estás en Python 3.8 o más: Operador walrus

Espero que te haya parecido interesante. Si conoces más cosas del estilo que se puedan hacer con Python, te leo en los comentarios!

Recuerda entrar en la web de Core si quieres aprender Data Sciente/Machine Learning o aprender a programar "Cloud Native"!

Hasta el siguiente post!

Trabajando a 100 por hora en Jupyter Notebook

Ale Sánchez — Sat, 10 Jul 2021 12:40:08 +0000

Qué es Jupyter

Para el que no lo conozca, el Proyecto Jupyter es una herramienta diseñada para crear documentos con código, ecuaciones, imágenes... que puedes ejecutar en vivo.

Es tremendamente útil con fines académicos y con el objetivo de compartir código.

Es muy usado para investigación y enseñanza, como es el caso que nos ocupa.

En mi caso, uso Jupyter en el curso de Data Science y Machine Learning que estoy haciendo en la academia Core Code School. La verdad, los cursos molan bastante y no necesitas conocimiento previo para embarcarte en ellos (toma publi, Marc).

Una vez hechas las presentaciones, vamos a ver cuál es el objetivo de este post.

¿Por qué modificar lo que viene de base?

Creo que la respuesta a esta pregunta es bastante obvia... ~~porque puedo~~ para intentar mejorar la experiencia con la herramienta.

La idea de todo esto es modificar la interfaz y el comportamiento de Jupyter para mejorar tu productividad y el flujo de trabajo de forma que puedas hacer el mismo trabajo en menos tiempo.

Pre-requisitos

No es parte de este post explicar cómo funciona Jupyter ni cómo instalarlo. Se asume que tienes python y Jupyter en tu equipo (preferiblemente con Anaconda) y que sabes manejarte con lo básico en jupyter.

Instalar los paquetes

Antes de empezar necesitas instalar unos paquetes de python para que Jupyter se entienda con las extensiones y los temas.

Para poder gestionar temas necesitas instalar jupyter-themes con el comando:

pip install jupyterthemes

Una vez tienes eso, toca ir a por el paquete para gestionar extensiones. En este caso es jupyter_contrib_nbextensions:

conda install -c conda-forge jupyter_contrib_nbextensions

Y una vez que tienes ese paquete, falta instalar los archivos necesarios en Jupyter. Afortunadamente, el paquete expone un comando para eso:

jupyter contrib nbextension install --user

Y ya lo tienes todo listo para empezar a ponerlo a tu gusto.

Lo primero es lo primero

Las extensiones y la productividad están muy bien, pero aquí hemos venido a la fantasía, y por eso voy a empezar con los temas.

Nota: Te recomiendo parar Jupyter y borrar la caché del navegador antes de cambiar el tema.

La extensión de los temas expone el comando jt para gestionarla. Para listar los temas disponibles usa el comando:

jt -l

En mi caso tengo disponibles los temas:

Available Themes: 
   chesterish     
   grade3
   gruvboxd
   gruvboxl
   monokai
   oceans16
   onedork
   solarizedd
   solarizedl

A mi, personalmente, el que más me gustó es oceans16. Para activarlo se usa el comando jt -t [nombre_del_tema]. Pero hay otra serie de opciones que se pueden usar para cambiar la fuente y muchas cosas más.

En mi caso, voy a cambiar la fuente del código a FiraCode y la del texto y el markdown a Merriweather. Para eso voy a usar los a argumentos -f (fuente del código), -nf (fuente del notebook) y -tf (fuente del texto/makrdown):

jt -t oceans16 -f firacode -nf merriserif -tf merriserif

Puedes cambiar el tamaño de la fuente, qué elementos se muestran y muchas cosas más. En mi caso, la configuración que he elegido es:

jt -t oceans16 -f firacode -nf merriserif -tf merriserif -fs 95 -altp -tfs 11 -nfs 115 -cellw 88% -T -N -kl

Y queda así:

Ahora sí, las extensiones

Una vez que ya lo tienes bonito, a por las extensiones para trabajar mejor.

Si, como yo, tienes la versión de Jupyter 6, vas a tener que desactivar esta casilla en la pestaña NbExtensions:

Para poder instalar las extensiones. Esto es porque todas las extensiones ponen que son para Jupyter 4 y 5. Sin embargo, yo las he probado con la versión 6 y funcionan todas.

Ahora sí, sin más rodeos, vamos con ellas (las que yo tengo).

Tree Filter

Esta extensión añade una barra de búsqueda a la vista de archivos de Jupyter. Esto te permite buscar archivos o carpetas de manera mucho más rápida y sencilla.

Table of Contents (2)

Esta extensión hace lo que promete. Pone de manera visual el índice del notebook para que puedas tener una navegación rápida:

Para activarla y desactivarla sólo tienes que clicar el botón con el símbolo de la lista en la barra de herramientas.

Desde la pestaña de NbExtensions puedes configurar la apariencia, cuántos subniveles se muestran, etc.

Collapsible Headers

Parecido al anterior. Te permite ocultar secciones completas contrayendo su cabecera. Con esto puedes ocultar el contenido de las secciones que no necesites para navegar mucho más rápido por el notebook.

Con la flecha izquierda contraes la cabecera de la celda seleccionada y con la derecha la expandes. De nuevo, tienes más configuraciones desde la pestaña de extensiones.

Snippets

Esta es una muy simple pero que me parece realmente útil. Puedes definirte fragmentos de código para colocar con un click en una celda.

La configuración no es tan sencilla como en las demás, pues tienes que definir los snippets en un archivo JSON llamado snippets.json y colocarlo en la carpeta:

$(jupyter --data-dir)/nbextensions/snippets/

Si, por ejemplo, quieres un snippet para importar numpy y pandas llamado np, pandas definirías un JSON como el que sigue:

{
    "snippets" : [
        {
            "name" : "np, pandas",
            "code" : [
                "import numpy as np",
                "import pandas",
            ]
        }
    ]
}

Ahora podremos incrustar nuestro snippet usando el menú de la barra de herramientas:

Initialization Cells

Muy de la mano con la de snippets se puede usar esta. Esta extensión te permite marcar algunas celdas como "celdas de inicialización", para ejecutarlas automáticamente al abrir un notebook, o a mano, o cuando prefieras.

Lo primero que hay que hacer es mostrar la casilla de la extensión a través del menú View > Cell Toolbar > Initialization Cell

Una vez hecho eso, ya podrás marcar casillas como inicialización:

Y, para lanzarlas todas, solo tendrás que clicar el icono de la calculadora de la barra de herramientas.

Autopep8

No hay mucho que decir. Te permite formatear el código de una celda acorde a las reglas de autopep8.

Para hacerlo, se puede usar el mazo que hay en la barra de tareas:

Otra opción (la que yo he hecho) es configurar un atajo de teclado para formatear una celda. Desde la página de extensiones, configura la opción Hotkey to use to prettify the selected cell(s) con el atajo que prefieras. En mi caso he usado Ctrl+Alt+F.

Nota: Para que funcione, necesitas tener instalada la extensión autopep8 en tu entorno. Puedes hacerlo con pip install autopep8

Comment/Uncomment Hotkey

A esta no voy a darle muchas vueltas. Te permite definir un atajo de teclado para comentar una línea o un bloque de código.

Yo lo tengo configurado con el atajo Ctrl+Shift+7, igual que Visual Studio Code.

ExecuteTime

Esta extensión es más informativa que otra cosa. Te añade una línea debajo de la celda con el tiempo que ha tardado en ejecutarse.

Esta extensión permite configurar el formato en el que aparecen las marcas temporales y cuándo se limpian.

Variable Inspector

Tampoco deja mucho a la imaginación. Cuando pulsas el botón con una mirilla de la barra de herramientas, te va a abrir una ventana flotante con las variables que tienes ahora mismo y sus valores.

Esa ventana la puedes actualizar, minimizar y cerrar :) Muy útil para hacer una suerte de depuración.

Hinterland

Esta extensión lo que hace es extender una funcionalidad que ya tiene Jupyter. Cuando vas escribiendo código, puedes autocompletar pulsando Ctrl + Espacio. Esta extensión lo que hace es que el autocomlpetado (Intellisense) funcione automáticamente mientras escribes, como en casi cualquier IDE.

Scratchpad

Por último, esta extensión te permite abrir una especie de celda aparte en la que puedes ejecutar código para probar, volátil.

En esa celda aparte tienes acceso a todas las variables del notebook, tanto para consulta como para modificación. Puedes ver un vídeo de cómo funciona sacado directamente desde su documentación.

Conclusiones

Pues no mucho más que decir :). Ahora tienes tu Jupyter precioso y echas fuego por las orejas cuando trabajas.

Si tienes más extensiones o flujos de trabajo que merezcan la pena compartir, te leo en los comentarios.

Y, por supuesto, visita la página de Core Code School para ver sus cursos!!

La relación entre una Lambda de Python y los Simpsons

Ale Sánchez — Wed, 23 Jun 2021 15:00:39 +0000

Pues, aparentemente, has leído bien. Hace aproximadamente un mes empecé un Bootcamp de Big Data y Machine Learning en Core Scool que está siendo una pasada (casi no se ha notado la publicidad). El caso es que en una de las clases se nos presentó el siguiente código cuando hablábamos de currying:

potencias = {}

for number in [2, 4, 16]:
    potencias[number] = lambda x: number**x

print(potencias[2](4))

Todos en clase pensamos (ilusos de nosotros...) que el resultado de ese print iba a ser 16 ( $2^4$ ) pero cuál fue nuestra sorpresa (y la tuya si pruebas ese código) al ver que el resultado era nada más y nada menos que 65536. Pero... ¿por qué?

Para resolver esa cuestión tengo que hablar del scope y, para eso, voy a usar a Los Simpons. Vamos al lío.

A por las metáforas

Podría hacerte una definición técnica de lo que es el scope, cómo funciona y cómo afecta, pero la verdad es que ese no es mi estilo en absoluto, así voy con una metáfora.

Como definición súper general, simplificada y (si la analizas con detalle) parcialmente incorrecta, puedo decir que el scope es una forma que tiene python (y prácticamente cualquier lenguaje) de compartimentar los accesos a las variables.

Dicho esto, imagina que el código es una casa. Concretamente, la casa de los Simpsons.

En esa casa hay distintas habitaciones e incluso distintas plantas. Imagina también (por simplificar) que todas las estancias son independientes entre sí y que, lo único común a todas ellas son los pasillos y las escaleras.

Y, por último, imagina que si tú estás en una habitación y necesitas algo, solo puedes ir a buscarlo saliendo de habitaciones.

Con esto vas a entender el scope perfectamente. Trasladando esto a código, podríamos decir que cada habitación de la casa es un scope distinto. Por simplicidad, vamos a quedarnos solo con la planta de arriba. Si pinto los scopes que habría en la casa de Los Simpsons, quedaría algo como:

Si te fijas, cada habitación tiene su propio color, porque es un scope distinto. Incluso las habitaciones que están dentro de otras (el baño que está dentro de la habitación de Homer y Marge), ¡tienen su propio color!

Una cosa más es que todo el pasillo y las escaleras tienen el mismo scope, el rojo intenso.

Si yo te digo que como tienes una cama en la habitación de Bart y otra en la de Lisa, tienes 2 camas juntas, me llamarías loco, ¿verdad? Porque no están juntas, están en habitaciones (scopes) diferentes. Pues con las variables es lo mismo.

Vamos a detallar esto un poco más, colocando objetos en algunas habitaciones:

Puedes ver que he colocado una bici en el cuarto de Homer y Marge, un jarrón (ánfora) en el de Bart y un tambor en el pasillo.

Ahora imagina que, como dijimos antes, no puedes ir a buscar nada entrando a otra habitación, solo saliendo. Si estuvieses en el cuarto de Lisa y necesitases un jarrón, ¿podrías ir al cuarto de Bart a por él? Veamos...

Sales de la habitación de Lisa al pasillo ✔
Entras al cuarto de Bart ❌

Has tenido que entrar en una habitación, así que no puedes ir. Por lo tanto podemos decir que, estando en el cuarto de Lisa, no tienes ningún jarrón.

Vamos a intentar lo mismo, desde le baño de la habitación de Homer y Marge, pero con la bici.

Sales del baño a la habitación de Homer y Marge ✔

Ya tienes la bici!! Y, una vez que la tienes, puedes usarla todo lo que necesites.

Una última prueba! Vamos a intentar ir a por el tambor desde el baño de Homer y Marge:

Sales del baño a la habitación de Homer y Marge ✔
Sales de la habitación al pasillo ✔

Pues también puedes! Entonces, como regla general puedo decir que, desde cualquier habitación, puedes coger lo que esté en el pasillo.

Sin embargo no al contrario. Desde el pasillo, no puedes coger nada de ninguna habitación (porque no puedes entrar).

¿Qué tiene todo esto que ver con Python?

Lo bonito de todo esto es que es aplicable a Python y a (prácticamente) cualquier lenguaje moderno.

Si el lenguaje solo tuviese un único scope, desde cualquier parte del código podrías modificar cualquier variable y sería un poco caótico y difícil de depurar.

En Python hay 4 scopes distintos y hay un acrónimo para recordarlos: LEGB. Son las siglas (en inglés) de:

Local
Envoltura (Enclosing)
Global
Incorporado (Built-in)

Cómo se crea un scope en python

Python crea scopes cuando se define:

Una función lambda: Cuando haces lambda x: print(x) esa lambda está definiendo un scope local en el que existe la variable x.
Una función: Cuando creas una función con la palabra def, estás creando un scope. En el siguiente código:

def my_function(param_1, param_2):
  add = param_1 + param_2

  return add

Estás creando una función que define un scope en el que se definen las variables param_1, param_2 y add.

Clases: Al definir una clase con la palabra reservada class, también se crea un scope. En este caso es un poco especial porque desde fuera sí puedes acceder al scope de la clase (más o menos). Así que vamos a dejar este caso aparte.

En cualquiera de estos 3 casos, estarás creando un scope local y, por tanto, un código como este:

def local_scope(a):
  print(a)

local_scope("Hola") # >> "Hola"

Funciona perfectamente y estaría creando un scope local en local_scope que contendría la variable a.

IMPORTANTE: Un scope se crea EN LA LLAMADA a la función y NO en su definición. Por eso, si llamas 100 veces a la función local_scope, tendrás 100 scopes diferentes. Esto es así incluso si haces llamadas recursivas.

Otra cosa importante es que, cuando tú defines una variable en la cabecera de una función, esa variable ya existirá en el scope de esa función. O lo que es lo mismo, ya está definida y puedes usarla en el scope local de esa función todo lo que necesites.

Scope local

Es el que acabas de ver. Equivalente a una habitación. Defines una función (lambda o normal), y ahí tienes tu scope. Todo lo que definas en la cabecera o en el cuerpo de la función formará parte de tu scope local.

Envoltura

Esto no es más que un scope dentro de un scope. Lo mismo que pasaba con el baño en el cuarto de Homer y Marge. Para hacer esto, lo único que tienes que hacer es crear un scope dentro de otro. Por ejemplo, anidando funciones:

def enclosing(param_out):
  other_var = "HI"
  def enclosed(param_in):
    print(other_var)
    print(param_out)
    print(param_in)

  return enclosed

Vamos a ver los scopes de este código de una manera un poco más gráfica:

La función enclosing estaría definiendo el scope naranja y la enclosed un scope dentro del anterior.

Por lo tanto, si ejecutamos ese código:

>>> function_in = enclosing("Out") 
>>> function_in("In") 
HI
Out
In

Pero sin embargo, si intentamos acceder directamente a la función interna:

>>> enclosed("In")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'enclosed' is not defined

Se queja porque no podemos entrar en habitaciones, solo salir de ellas!

Global

El scope global sería el pasillo. Es un scope que está disponible para todos, es el mas general y también se le llama scope de módulo (module scope). Es el scope general que tienes en tu archivo de Python. Un ejemplo:

super_global = "Estoy fuera de todo"

def my_function():
  print(super_global)

def my_function_enclosing():
  def my_function_enclosed():
    print(super_global)

  return my_function_enclosed()

>>> print(super_global)
Estoy fuera de todo
>>> my_function()
Estoy fuera de todo
>>> my_function_enclosing()
Estoy fuera de todo

Todas tienen acceso a la variable super_global porque sólo tienen que salir de habitaciones para ir a buscarla.

Incorporado (Built-in)

Este es un scope especial, es un scope en el que hay cosas que vienen por defecto con python y que no es necesario declarar, importar ni nada. Un ejemplo de lo que hay en este scope son las funciones len, sorted, max...

Por eso podemos hacer cosas como:

>>> lst = [1, 2, 3, 4, 5]
>>> len(lst) 
5

Sin necesidad de definir ni importar len en ninguna parte.

¿Cómo podemos añadir elementos a un scope?

Hay varias maneras de hacer esto. La primera y la más evidente es declarando una nueva variable. Al hacer my_var = "Hola" estás añadiendo una nueva variable my_var a tu scope.

Otra manera es usar un import. Cuando tú haces import math estás trayendo todo lo que haya en el scope global del módulo math a tu scope. Por eso puedes usar funciones como sqrt en tu scope solo si importas primero math.

Por último, me gustaría remarcar que la única forma de declarar una nueva variable en un scope no es con la forma var = "algo". Cuando haces:

def func(param):
  print(param)

Estás añadiendo la variable param al scope de la función func aunque no estés asignándola a nada en ese momento. En el momento de la llamada se creará un scope para esa función y esa variable se creará automáticamente en el scope con el valor que haya recibido el parámetro.

Un último apunte es que al hacer:

for number in range(1, 20):
  print(number)

También estás añadiendo la variable number a scope global (si el for lo tienes dentro de una función, lo añadirías a esa función).

¿Y qué leches es eso del shadowing?

El shadowing no es más que "eclipsar" una variable de un scope externo con una variable de un scope interno. Vamos a verlo con un ejemplo:

var = "Soy globalísima"

def modify():
  var = "Soy localísima"
  print(var)

Párate un minuto y piensa qué debería imprimir ese código...

Te pongo la respuesta:

>>> print(var)
Soy globalísima
>>> modify()
Soy localísima
>>> print(var)
Soy globalísima

Un momento, un momento... ¿no debería aparecer "Soy localísima" dos veces? Porque estoy modificando la variable del scope global en la función, ¿cierto?

Lo cierto es que no. Lo que estoy haciendo es definir una variable nueva en el scope local que eclipsa (hace shadowing) a la del scope global.

De la misma manera, con scopes de envoltura, si hago esto:

def outter():
  var = "Estoy fuerísima"
  def inner():
    var = "Estoy dentro del tó"
    print(var)

  print(var)
  inner()
  print(var)

Y ejecuto esa función, habrá un comportamiento similar al anterior:

>>> outter()
Estoy fuerísima
Estoy dentro del tó
Estoy fuerísima

Al re-asignar la variable var en la función inner, lo que estoy haciendo es declarar una variable nueva que hace shadowing a la externa.

¿Pero todo esto no iba de una lambda?

Pues sí!! Y ahora puedes entender perfectamente por qué pasaba aquello en nuestro código. Vamos a volver al código inicial:

potencias = {}

for number in [2, 4, 16]:
    potencias[number] = lambda x: x**number

print(potencias[2](4))

Según nuestra intuición eso debería dar 16, pero da 65535. Vamos a analizar el código con los conocimientos que tenemos ahora.

Sabes que tenemos un scope global que envuelve a todo el código.

Además sabes que una lambda, como buena función, crea otro scope.

Pero sabes una cosa más... Que los scopes de una función se crean en el momento de su llamada y no en su definición.

Eso significa que, cuando creas la primera lambda, el number que tiene como exponente será 2, en la segunda lambda será 4 y en la tercera 16.

Pero una vez que termina el bucle, number permanece definido como 16, pues es el último valor de la lista. Entonces cuando llamas a potencias[2] se llama la primera lambda, en ese momento se crea un scope, y se busca number en el scope superior (el global) y, como es 16, al hacer potencias[2](4) estamos haciendo $16^4$ , que es nada más y nada menos que nuestro resultado, 65535.

¿Cómo solucionarlo?

Sabes que necesitas que number, el exponente, quede definida en el scope de la lambda en el momento de la creación, en vez de acceder a la del scope global.

Para eso sanes que si defines esa variable como argumento de la lambda y la igualamos a la superior, esa variable quedará definida y fijada con ese valor al crearla, incluso si la llamamos igual (por el shadowing).

Si cambias el código a:

potencias = {}

for number in [2, 4, 16]:
    potencias[number] = lambda x, number=number: x**number

print(potencias[2](4))

Estás definiendo una variable number dentro de ese scope, que tomará por defecto el valor que tenga la variable del bucle homónima en ese momento. Por eso cuando llames a potencias[2](4), se creará un scope para esa función, pero con la variable number prefijada al valor que tenía en el momento de la creación de la lambda, pues ese valor por defecto es fijo.

Ahora sí, el resultado de esa ejecución es:

>>> print(potencias[2](4))
16

Cómo modificar el scope

Hay un par de opciones para modificar el scope de Python y, aunque útiles, debemos tratarlas con mucho cuidado.

Imagina que tienes, como en el ejemplo del shadowing, este código:

var = "Soy globalísima"

def modify():
  var = "Soy localísima"
  print(var)

Y tú necesitas irremediablemente modificar la variable var dentro de la función. Hay una forma de modificar el scope de esa función para que esa variable se "enlace" bidireccionalmente con la del scope global.

Esto significa que tanto si la lees como si la modificas estarás modificando la del global. Para esto se usa la palabra global seguida del nombre de la variable que queremos enlazar con una global. Si bien vimos que el código anterior devolvía:

>>> print(var)
Soy globalísima
>>> modify()
Soy localísima
>>> print(var)
Soy globalísima

Al cambiar el código a:

var = "Soy globalísima"

def modify():
  global var
  var = "Soy localísima"
  print(var)

El resultado de ejecutarlo nuevamente será:

>>> print(var)
Soy globalísima
>>> modify()
Soy localísima
>>> print(var)
Soy localísima

Hemos modificado la variable global satisfactoriamente!

Ahora imagina, por otro lado, el siguiente código que vimos también en el shadowing:

def outter():
  var = "Estoy fuerísima"
  def inner():
    var = "Estoy dentro del tó"
    print(var)

  print(var)
  inner()
  print(var)

Y, de nuevo, necesitas irremediablemente modificar la variable var dentro de la función inner. En este caso global no nos sirve, pues estaríamos enlazando var a una variable del scope global llamada var, que no existe. Si intentamos hacer esto:

def outter():
  var = "Estoy fuerísima"
  def inner():
    global var
    var = "Estoy dentro del tó"
    print(var)

  print(var)
  inner()
  print(var)

El resultado es:

>>> outter()
Estoy fuerísima
Estoy dentro del tó
Estoy fuerísima

Que es lo mismo que antes, solo que ahora en el scope global, tendremos una variable var con el valor "Estoy dentro del tó", que no es lo que queremos.

En este caso python nos ofrece otra palabra que se usa exactamente igual que la anterior y es nonlocal. Esto lo que hace es buscar la variable etiquetada como nonlocal en el scope superior (y en el superior de ese, y así sucesivamente) y enlazarla de manera bidireccional igual que se hacía con global. Por tanto, si cambiamos el código a:

def outter():
  var = "Estoy fuerísima"
  def inner():
    nonlocal var
    var = "Estoy dentro del tó"
    print(var)

  print(var)
  inner()
  print(var)

Estaremos enlazando la variable var de inner, con la variable var de outter y el resultado será:

>>> outter()
Estoy fuerísima
Estoy dentro del tó
Estoy dentro del tó

Ahora sí, una modificación de la variable exterior desde la función interior.

Importante: nonlocal busca en los scopes superiores de manera sucesiva hasta llegar al global. Si cuando llega al global no ha encontrado esa variable, dará un error. nonlocal no permite enlazar una variable interna con una global, para eso tenemos la palabra global. Un ejemplo:

var = "Hola"
def func():
  def inner():
    nonlocal var
    var = "Adios"
  return inner()

  File "<stdin>", line 3
SyntaxError: no binding for nonlocal 'var' found

Dice que no hay ninguna variable var a la que enlazar. Sin embargo al cambiar por global:

var = "Hola"
def func():
  def inner():
    global var
    var = "Adios"
  return inner()

El código funciona sin problemas.

Algunas curiosidades de Python

El scope en los bucles

Ni un bucle for ni un bucle while definen un nuevo scope. Por tanto, cualquier variable que definas dentro de ellos seguirá viva fuera del bucle. Incluso la variable que definas en el bucle en sí!!

for number in range(5):
  print(number)

print(number)

El resultado de esa ejecución será:

0
1
2
3
4
>>> print(number)
4

La variable number sigue existiendo incluso después del bucle.

El scope en los bloques if

Pasa exactamente igual que en los bucles, toda variable que definas dentro de un bloque if, estará disponible después.

if True:
  var = "Hola"

print(var)

if True:
  print(var)

El resultado será:

Hola
Hola

Algo muy similar a lo que pasaba en el anterior caso.

El scope de los list/dict comprehension

Sin embargo, en los list comprehension el scope se comporta ligeramente distinto. Al ejecutar el código:

[number for number in range(5)]

Si luego intentamos acceder a number:

>>> [number for number in range(5)]
[0, 1, 2, 3, 4]
>>> number
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'number' is not defined

Porque en un list/dict comprehension, las variables no se crean en el scope en el que estén, sino que solo existen durante el comprehesion concreto.

Scope en un try/except

Cuando tenemos un bloque try/except podemos pensar que se van a comportar igual que un if, pero hay una particularidad. Imagina el siguiente código:

try:
  a = 1
except Exception as e:
  print("Error")

Si intentamos acceder a a:

>>> a
1

La tenemos disponible en el scope sin problema. Pero ahora mira este código:

try:
  raise ValueError()
except Exception as e:
  print(e)

Si ahora intentamos acceder a e:

>>> e
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'e' is not defined

La variable e, aunque se define en el except y se entra por ahí, no se crea en el scope.

Conclusiones

Pues básicamente has entendido cómo funcionan los scopes en Python, cómo puedes usarlos a tu favor y qué cosas debes tener en cuenta.

Además, has aprendido qué estructuras crean scopes en Python, cómo traer variables nuevas a tu scope e incluso cómo modificar el comportamiento de los scopes en Python con global y nonlocal.

Para cualquier duda que tengas te leo en los comentarios y, para aprender cosas como estas y mucho más molonas, no dejes de mirar los cursos de Core Scool.

Nos vemos en el próximo post!

Implementing key objects in Unity by a newbie. Part 2.

Ale Sánchez — Sun, 16 May 2021 07:45:50 +0000

In the previous part we built the foundations for implementing the key objects.

In this post we are going to finish that task developing the actionable by key specific object and testing everything we developed until now.

In the first part the last step was the 3, so here we will start directly in the 4, for preserving the tags in the repo :)

Step 4: Actionable by key

Let's implement the key (sorry for that) part of the post! Our ActionableByKey class!

As we saw in the diagram, the ActionableByKey object used a feature called events! Events in C# are a way to notify that something happened. We are going to use that to send a message to the universe when an item has been picked. Start by defining the event we'll need.

Create a new folder called "Events" inside the "Scripts" one and put inside a file called "ItemPick":

public delegate void NotifyItemPick(ActionableObject pickedItem);

public static class ItemPickEvents {
    public static event NotifyItemPick OnItemPick;

    public static void NotifyItemPick(ActionableObject pickedItem) {
        OnItemPick?.Invoke(pickedItem);
    }
}

First we define a deletage called NotifyItemPick that will be called with an ActionableObject referencing the picked item.

The class itself will contain the OnItemPick event as static, so anyone can subscribe to it and a static method for notifying an item pick.

We have talked a lot about picking an item and objects that will be interacted when an item is picked, but haven't defined the item itself yet!

In order to represent our item, we need a KeyItem script that will define an object that has to be picked to activate another. Picking an object is some sort of interaction so... we can take advantage of our generic actionable object! Create a new folder called "Items" inside "Scripts" and, inside, create a "KeyItem" file:

public class KeyItem : ActionableObject
{
    protected override void InnerStart(){}

    protected override void InnerInteract() {
        ItemPickEvents.NotifyItemPick(this);
        Destroy(gameObject);
    }
}

As you can see, the inner start does nothing and the interaction just notify that itself has been picked, followed by the descruction of the picked item. Easy!

Now that we have the events as well as the key item, the next step is to create the actionable by key one. Create a file side by side with StandardActionableObject and call it ActionableByKey:

public class ActionableByKey : StandardActionableObject
{
    [Tooltip("This item will activate the actuator of this object when picked")]
    [SerializeField] KeyItem actionedBy;

    protected override void InnerStart()
    {
        base.InnerStart();
        SetIsInteractive(false);
    }

    private void OnEnable() {
        ItemPickEvents.OnItemPick += OnItemPick;
    }

    private void OnDisable() {
        ItemPickEvents.OnItemPick -= OnItemPick;
    }

    private void OnItemPick(ActionableObject pickedItem)
    {
        if(pickedItem is KeyItem && pickedItem.Equals(actionedBy)) {
            SetIsInteractive(true);
        }
    }
}

The first attribute is a reference to the key item that need to be picked to activate this object.

The InnerStart deactivates the interactions with this object.

We will subscribe to the OnItemPick event in the OnEnable and unsusbcribe in the OnDisable. The function bound to the event is called also OnItemPick.

In the OnItemPick method we check if the picked item is a KeyItem as well as the one that activates the interactions with the actionable object. If both conditions are met, activate the interactions :D

We are almost there! Just one more thing to code and we can jump back to the Unity editor!

Access the code for this step here

Step 5: How to interact with objects

Ok, we have set everything up so that when we interact with an object it works like a charm but... How can we interact with an object?

That is what we are going to solve here. In general terms, the approach is to throw Raycast from the player eyes (more or less), a unit of distance and a half away and check if it collides with a collider belonging to an IActionableObject GameObject (that's why we set a collider up in our door). If we find an actionable object, we will store a reference to it and show the interaction text. When the key for interacting is pressed, we will call the Interact function of the stored actionable object.

We will create a file called ObjectInteractuator inside the Scripts folder:

public class ObjectInteractuator : MonoBehaviour
{
    [SerializeField] InteractionText interactText;

    [SerializeField] LayerMask interactionMask;

    GameActions actions;
    Camera mainCamera;

    IActionableObject currInteractiveObject;

    private void Awake() {
        actions = new GameActions();
        actions.Player.Interact.performed += OnInteractPerformed;
    }

    private void OnEnable() {
        actions.Player.Enable();
    }

    private void OnDisable() {
        actions.Player.Disable();
    }

    private void OnDestroy() {
        actions.Player.Interact.performed -= OnInteractPerformed;
    }

    private void Start() {
        mainCamera = Camera.main;
    }

    // Update is called once per frame
    void Update()
    {
        CheckInteractions();
    }

    private void CheckInteractions()
    {
        Ray cameraRay = mainCamera.ViewportPointToRay(Vector3.one / 2f);

        RaycastHit hit;
        IActionableObject objectHit;

        // We are looking towards an interactive object an in range
        if (Physics.Raycast(cameraRay, out hit, 1.5f, interactionMask, QueryTriggerInteraction.Collide) 
            && hit.transform.TryGetComponent<IActionableObject>(out objectHit) 
            && objectHit.IsInteracterActive()
        ) {
            interactText.SetInteractionText(objectHit.GetInteractionText());
            currInteractiveObject = objectHit;

            interactText.Enable();
        }
        else if (interactText.enabled)
        {
            interactText.Disable();
            currInteractiveObject = null;
        }
    }

    private void OnInteractPerformed(InputAction.CallbackContext obj)
    {
        currInteractiveObject?.Interact();
    }

}

The first attribute is a reference to the InteractionText of the scene (we will create it later). The second is the interaction mask the raycast has to check for performing a hit (you can create a custom layer if you want, but in this example we will use the default one).

The GameActions are needed to listen for event sent when the interaction key is pressed. Finally, we need the Camera to cast the ray from it.

The last attribute is to store a reference to the current interactive object (the one we are looking at right now, if any).

In the Awake we will bind the OnInteractPerformed function to the Interact action, and will unbind it in the OnDestroy function. The only purpose of that function is to call the Interact method of the interactive object we are looking at right now (checking first if there is any).

The OnEnable and OnDisable functions are used to enable and disable the game actions.

In the Start we are storing the reference to the main camera and in the Update we are going to check for interactions.

The CheckInteractions is where the magic happens, let's look into it step by step.

First we construct a Ray that starts at the middle point of the viewport (that's why we use Vector.One / 2f).

Then we create two variables to store the hit of the raycast as well as the actionable object.

Then we have an if with three conditions. The first one:

Physics.Raycast(cameraRay, out hit, 1.5f, interactionMask, QueryTriggerInteraction.Collide)

This casts the previously created ray 1.5 units of distance away, storing the possible hit in the hit variable, colliding only with interactionMask and reporting with trigger colliders thanks to the QueryTriggerInteraction.Collide attribute. If that condition is met (an object has been hit), then it goes for the second one:

hit.transform.TryGetComponent<IActionableObject>(out objectHit)

That one asks if the collided object has a component implementing the interface IActionableObject. If so, it stores the found component in the objectHit variable and goes for the last check:

objectHit.IsInteracterActive()

This one just asks if the interactions are enabled for the collided object.

If all of that is met, we set the interaction text to the one returned by the collided object, store a reference to the collided object and enable the interact text component.

If any of the conditions fail it means that we are not looking to an interactive object, so we disable the interaction text and clear the reference.

And with that, we have all set for interacting with objects!! Let's move again to the editor for the final touches.

Access the code for this step here

Step 6: Attaching all needed scripts

Now it's time to start adding scripts to all of the GameObjects in the scene.

As we said earlier, we must create the elements needed for showing the interaction text. We are going to use an overlay canvas with a text. That text will be white so that it makes more contrast with the background.

After creating the canvas and switching the EventSystem to the new input system, we must attach the InteractionText script to the Text component in order to reference it in the ObjectInteractuator script.

To set up the interactor, we need to attach the ObjectInteractuator script to the FPSController. Then reference the text component we created in the previous step and set the interaction mask to Default.

The last step before we can begin to interact with our door is to make it a StandardActionableObject (for the moment).

Before that, we must fix a thing we forgot when creating the animation in Part 1. We need to make sure that the animation is not played on loop. For that, go to the animation file and uncheck the "Loop time" attribute. Then we just need to attach the StandardActionableObject script to it and fill the animation state name, which is "DoorOpen".

Now we are able to play around with our door opening and closing it. Our very last step is to make it actionable by a key!!

Access the code developed in this step here

NOTE: I changed the colliders of the doors so the player can walk across it. I created one trigger collider around the whole door for the raycast and one collider in the door itself to prevent the player from crossing it when closed.

Step 7: Making the door actionable by cube key

The last thing we need to finish our heroic journey is making the door interactive only when a specific item is picked. In a real game, that item would be a key, in our amazing AAA game, it will be the most cubic cube you'll ever see.

The first step is to place our cube and make it a KeyItem. Since it will be picked up and destroyed, we don't need any reverse interaction text.

And the last thing... Replace the script attached to the door with an ActionableByKey script and set the reference to our key. That's all! The door won't be interactive until we pick up the key!

Access the code of this step here

Conclussions... or something like that

So... yes... it's finished, it's working, it's awesome... I'm not crying, you're crying.

Now seriously, I hope you enjoyed the journey reading and following the steps as much as I enjoyed writing the posts and recording the videos.

As in the first part, feel free to make any suggestions, improvements, doubts, requests or whatever you want to say!

See you in the next post!

Implementing key objects in Unity by a newbie. Part 1.

Ale Sánchez — Wed, 12 May 2021 15:45:43 +0000

Hello everyone once again! Today I’m writing a post about Unity! I started developing using Unity just a few months ago, but despite having some experience in development, this is my first time with videogames.

I believe that explaining each step while having zero experience myself might be interesting and could provide other developers with some insight of the challenges that come with developing games.

I’m a newbie when it comes to developing videogames in general, and more particularly using Unity, so feel free to make any suggestions you might have, and also let me know if you believe there are more standardized ways to solve the problems I’m about to propose.

As a final note before we dive in, I would like to remind you that I’m no artist at all, therefore I won’t be creating any assets for the game from scratch (like 3D models, textures, animations and so on). I’ll be using free asset packs from the unity store :)

Step 0 - Preparing the basic environment.

Everything being developed in this post is publicly available in this repository.

Every step is going to be also accessible via Tags. For example, you can check the final code of step 0 here.

In this first part we are only setting up the minimum things we need to start working. This includes a first person player controller that was also implemented by me (not covered in this post). A ground plane with a wood tiling downloaded from the Assets Store (this package) and a door also downloaded from the assets store (this package).

That door is the one we are going to animate later for opening and closing it.

For the character movement I've set up the new input system so we can move with the standard WASD keys.

Feel free to check out the project and explore everything in there until you feel comfortable to move to the next step.

Note: For showing the cursor while playing the game, press ESC

Step 1 - Animating the door

In this step we are going to animate the door so it can be opened and closed. For that we are going to make the door rotate around the hinges, by rotating the SimpleDoor:Global_ControlSimpleDoor_MainDoor_LOD1 component around the Y axis.

First things first: If you haven’t done it already, make sure to display the animation window by clicking Window > Animation > Animation. Then switch to that tab, click the door and, in the Animation tab, click to create a new animation. Call it "Door".

Once we have the animation file, we are going to create the animation itself. Switch to the Animation tab and click the SimpleDoor:Global_ControlSimpleDoor_MainDoor_LOD1 component inside Aparment_Door prefab.

Now click the record button in the Animation tab and right click the Rotation attribute inside Transform section of SimpleDoor:Global_ControlSimpleDoor_MainDoor_LOD1 and click Add Key.

That will create a key frame in the frame 0 with the rotation set to (0,0,0). Then move to the frame 120 and change the rotation around the Y axis to 97º. It's important to change it in the rotation section instead of rotating directly in the scene view.

Now you should have 2 key frames, so you can stop recording and save the animation.

Now that we have the animation ready we have to set the animation controller up so we can control when to play the animation and how.

Show the animator tab by clicking Window > Animation > Animator and click the Aparment_Door prefab so you can manipulate the animation state machine of the door.

We are going to create a new state and call it Idle. Then make the layer default one and uncheck the "Write Defaults" checkbox.

Next step is create a transition from the Idle state to the already existing Door state and uncheck the "Has Exit Time" checkbox from the transition. Also uncheck the "Write Defaults" checkbox from the Door state.

Finally, the last steps we need to follow are to change the door state name to DoorOpen, and create a new Float parameter which we will call direction. That param will be used to control whether the animation has to be played regularly or backwards. To make that happen we must go to the DoorOpen state and under Speed parameter there will be a greyed Multiplier parameter. That is what is going to allow us to reverse the animation, so check the "parameter" checkbox and the drop down should show the "direction" parameter we created earlier.

To check that everything is working fine we have to play the game and check that the Idle state is played on loop.

Access all the step changes here.

Step 2 - Making generic actionable objects

Now it's time to code!

We are going to start creating a generic type for defining actionable objects. Since we are going to implement not only standard actionable objects but also actionable by key or by trigger (in upcoming posts), we'll create the foundations first.

We are going to use inheritance for that. If you don't know what inheritance is, is a technique that allows us to reuse and extend functionality by using parent-child classes. For a more extended a technical definition, head to someone who knows more than me.

We will see each part in detail when we reach them. We are going to define an interface to make our life easier when it comes to detect an actionable object and also a specific class for each type of actionable object, extending the generic classes with specific functionality. And for the key objects specifically, we will take advantage of the C# events.

Start creating the following folder structure:

├───Scripts
│   ├───ActionableObjects
│   │   └───Generics

All of the files created in this section are going to be placed inside the Generics folder.

Defining the interface

Our interface is an easy one:

public interface IActionableObject
{
    void Interact();
    string GetInteractionText();
    bool IsInteracterActive();
}

We have to define an Interact method which will be called when the actionable object is interacted and will trigger whatever behavior we want.

GetInteractionText returns the text to show when looking at the object (if any). For example: "Press A to open".

IsInteracterActive is for telling us if the object is interactive or not (for a key object, it will return false until the key is picked up).

ActionableObject and InteractionText

Now that our interface is ready to be used to detect actionable objects, let's move to our other two generic components. First the InteractionText:

[RequireComponent(typeof(Text))]
public class InteractionText : MonoBehaviour
{
    private Text m_text;

    private string m_initialText;
    private string m_interactionText;

    private void Start() {
        m_text = GetComponent<Text>();

        m_initialText = m_text.text;
    }

    private void Update() {
        if(m_text.enabled) {
            m_text.text = $"{m_initialText}{m_interactionText}";
        }
    }

    public void SetInteractionText(string interactionText) {
        m_interactionText = interactionText;
    }

    public void Enable() {
        m_text.enabled = true;
    }

    public void Disable() {
        m_text.enabled = false;
    }

    public bool IsEnabled() => m_text.enabled;
}

The first thing we are going to do in this code is to forcefully bound the script to a GameObject with a Text component.

The class will have a referente to the Text component and two attributes for holding the initial text and the interaction text.

We are going to use the Start method to store the reference to the text component and setting the m_initialText to the text inside the component.

In the Update we are just setting the text of the component to a combination of the initial text and the interaction text. With that, we can add a common starting text to all interaction texts if needed. For example prepending "Press X to" to every interaction text.

The last thing is a function for changing the interaction text.

NOTE: We could enhance the performance by having a flag indicating when the interaction text has changed and only updating it when changed, instead of in every Update call.

And now our ActionableObject:

public abstract class ActionableObject : MonoBehaviour, IActionableObject
{

    [Header("UI")]
    [Tooltip("The text that will appear in the overlay before interacting with this object")]
    [SerializeField] string interactionText = "open";

    [Tooltip("The text that will appear in the overlay after interacting with this object")]
    [SerializeField] string interactionTextReverse = "close";

    protected bool m_interacted = false;

    protected bool m_interactive= true;

    private void Start() {
        InnerStart();
    }

    protected abstract void InnerStart();

    public string GetInteractionText()
    {
        return !m_interacted ? interactionText : interactionTextReverse;
    }

    public void Interact() {
        InnerInteract();
        m_interacted = !m_interacted;
    }

    protected virtual void InnerInteract() {}

    public virtual bool IsInteracterActive() => m_interactive;

    public virtual void SetIsInteractive(bool isInteractive) => m_interactive = isInteractive;
}

This class must be abstract because we need to force a specific implementation for each type of actionable object.

First, we define some serialized fields that we will need. The interactionText is "open" by default (remember we are prepending it with the m_initialText of the InteractionText). The interactionTextReverse is the text to show to "reverse" the action (if needed). For example open/close.

The attributes m_interacted and m_interactive indicates whether the object is in the "interacted" state (interacted and not reverted) and if is interactive, respectively.

The Start method does nothing else than calling an abstract InnerStart. This is done in order to avoid a reimplementation of the generic Start without calling the super. This is useful when we need to force some behaviour in the parent class that cannot be overriden (as in the Interact function). Is some sort of template method.

GetInteractionText just returns the interaction text or the reverse one depending on the m_interacted flag.

Interact is similar to the Start function. It's called when the object is interacted and just calls the InnerInteract (which will hold the specific interaction code) and flips the m_interacted flag.

IsInteracterActive and SetIsInteractive are the getter and setter for the m_interactive flag.

And that's all for this step! We have just implemented our generic actionable objects! Let's move to the next step!

Remember, you have the code developed in this step here

Step 3: Standard actionable objects

Here we are going to implement the specific class for a standard actionable object. This means that it's not actionable by key, that triggers an animation and that is "reversible" (you can, for example, open and close a door). I consider this the standard since it was the first type of actionable object I implemented and will be the one which will be used more extensively in our game.

You may remember that we used some hardcoded strings in the editor when setting up the animations (a parameter called "direction"). Instead of using literals we are going to extract that to constants, to avoid having hardcoded strings across all our codebase.

Create a folder called "Constants" inside our "Scripts" folder and, inside it, create a file called "Animation":

namespace AnimateDoors.Animation
{
    public static class AnimationConstants {
        public static string ANIMATION_DIRECTION = "direction";
    }
}

We are isolating those constants in the Animation namespace to avoid collisions with the script name and the Unity Animation component. We are defining a constant called ANIMATION_DIRECTION with the direction parameter name.

Now let's create our StandardActionableObject class inside our Scripts/ActionableObjects folder:

[RequireComponent(typeof(Animator))]
public class StandardActionableObject : ActionableObject
{
    [Header("Animation")]
    [Tooltip("The animation state to play when interacting with this object")]
    [SerializeField] string animationState;

    protected Animator m_animator;

    protected override void InnerStart()
    {
        m_animator = GetComponent<Animator>();        
    }

    protected override void InnerInteract()
    {
        UpdateAnimation();
    }

    private void UpdateAnimation() {
        m_animator.SetFloat(AnimationConstants.ANIMATION_DIRECTION, !m_interacted ? 1f : -1f);
        m_animator.Play(animationState);
    }
}

First we are going to require the Animator component to trigger the animation.

Then, define an attribute to store the name of the state in the animator to play when the object is interacted.

The InnerStart will just store a reference to the Animator.

The InnerInteract will call to UpdateAnimation and, that one, will set the "direction" parameter to 1 or -1 depending on the m_interacted flag. Remember that the direction controls the speed of the animation. If the object has not been interacted we are going to set the speed value to 1 and the animation will be played forward. If it has been interacted, the direction will be -1, so it will be played backwards. Right after that, we will play the state stored in the animationState attribute.

And that's all! Easy, right? That's why we invested some time in the parent class, so the children are easy to implement.

Access the code of this step here.

Let me stop here for now and finish the implementation in a following post. In the next one we will implement the specific classes for each type of actionable object and set everything up in the editor to use it.

Please feel free to make any suggestions and propose improvements to the code in this post, as well as any doubt you might have! Stay tuned for the next post in which we will finish implementing our key objects!

Generating Microservices with NestJS and schematics

Ale Sánchez — Sat, 10 Oct 2020 10:40:34 +0000

Welcome back to another super post about microservices and NestJS! We have been working on this project for a while and I decided to share with you how to use this and why we built a template project. So... let's begin!

Rebember: the template project generator package is publicly hosted in github

What are schematics?

If you don't know what schematics are, I'll do a quick overview about what are they. But I recommend you to take a look at the official documentation.

To sum it up, schematics are some sort of blueprints but for code. Yo define with a special templating language the files you want to generate and the run the schematics engine on it for generating the final files.

And what does all of this to do with NestJS? The cool thing is that Nest CLI uses angular schematics under the hood and, even better, they allow you to reference a custom collection with schematics!

That means that you can create your custom schematics and still get all the features from the Nest CLI, cool right??

Why a project generator?

We in Rebellion believe a lot in the concept that Netflix used in one of their tech talks, which is the knonw "Paved roads".

Paved roads mean (from my point of view) develop and have the tools needed for speeding up repetitive tasks.

For example, everytime we have to create a new project for a microservice we have to generate the default NestJS project, add the microservices package, add the NATS package, add persistence layer, create some global interceptors... These set of tasks are always the same and can be automated in an easy way. And that way is using a generator with schematics.

How to use it?

Using the project is simple, you just have to install it as a global NPM package and reference it in the Nest CLI.

npm install -g @rebellionpay/nest-ms-template

# for generating an app
nest g -c @rebellionpay/nest-ms-template app

# for generating a controller
nest g -c @rebellionpay/nest-ms-template ctrl

Then you just have to answer the questions and the files are going to be generated.

What includes this template?

THIS IS REALLY IMPORTANT

This project is, as said, a paved road for rebellion pay. This means that the functionalities included are the ones that fit the needs of our company and our team.

Being that said, let me guide you through the generated files of a project.

Let me put the answers given to the questions.

? What name would you like to use for the new project? sample-project
? Who is the author of the project? Rebellion Pay <backend@rebellionpay.com>
? Which is the description of the project? This is a sample project
? Which is the project license? MIT
? In which port will it run? 3000
? Which transport layer would you like to use? NATS
? Are you building a pure app? No
? Are you going to use persistence in a DB? Yes
? Which database would you like to use? mongodb
? Are you going to make the CD with spinnaker? Yes
? What is the spinnaker API url? https://testing.spinnaker.com
? In which kubernetes namespace will this app going to be deployed? default

For that set of answers, the following files are generated:

.
├── .vscode
│   └── launch.json
├── kubernetes
│   └── manifest.yml
├── src
│   ├── config
│   │   ├── MongoConfigService.ts
│   │   └── NATSConfigService.ts
│   ├── factory
│   │   └── winstonConfig.ts
│   ├── filters
│   │   └── ExceptionsFilter.ts
│   ├── interceptors
│   │   ├── InjectMetadataInterceptor.ts
│   │   ├── MetricsInterceptor.ts
│   │   └── TimeoutInterceptor.ts
│   ├── interface
│   │   └── MicroserviceMessage.ts
│   ├── message
│   │   ├── message.module.ts
│   │   ├── message.service.spec.ts
│   │   └── message.service.ts
│   ├── metrics
│   │   ├── metrics.module.ts
│   │   └── metrics.service.ts
│   ├── app.controller.spec.ts
│   ├── app.controller.ts
│   ├── app.module.ts
│   ├── app.service.ts
│   └── main.ts
├── test
│   ├── app.e2e-spec.ts
│   └── jest-e2e.json
├── .env.example
├── .eslintignore
├── .eslintrc.js
├── .gitignore
├── .gitlab-ci.yml
├── .prettierrc
├── README.md
├── nest-cli.json
├── package.json
├── tsconfig.build.json
└── tsconfig.json

In the root folder we have a standard README file, the Typescript config files, a package.json and a nest-cli.json, which is used for monorepo projects. We have also a sample .env file and the ESLint/prettier config files. And, lastly, a gitignore and a gitlab CI file.

There are also a .vscode and a kubernetes folder. The .vscode folder has a launch.json with a standard config for nestjs projects. The kubernetes folder contains a manifest file with a service and a deployment.

We are going to use block quotes to explain the differences in the code if you choose other alternatives to the questions.

main.ts

In the src folder we have the main.ts file. There is the function that bootstraps the nest app. In the case of our answers the main.ts bootstraps an hybrid app.

if (process.env.NODE_ENV === 'production') {
  initializeAPMAgent({
    serverUrl: process.env.ELASTIC_APM_SERVER_URL,
    serviceName: process.env.ELASTIC_APM_SERVICE_NAME,
    secretToken: process.env.ELASTIC_APM_SECRET_TOKEN,
  });
}

async function bootstrap() {
  const logger: LoggerConfig = new LoggerConfig();
  const winstonLogger = WinstonModule.createLogger(logger.console());

  const app = await NestFactory.create(
    AppModule.register(),
    {
      cors: true,
      logger: WinstonLogger
    }
  );

  const natsConfigService : NATSConfigService = app.get(NATSConfigService);
  const configService : ConfigService = app.get<ConfigService>(ConfigService);

  app.use(helmet());
  app.useGlobalFilters(new AllExceptionsFilter());


  app.connectMicroservice({
    ...natsConfigService.getNATSConfig
  });

  const globalInterceptors = [];

  if (process.env.NODE_ENV === 'production') {
    globalInterceptors.push(
      app.get(ApmHttpUserContextInterceptor),
      app.get(ApmErrorInterceptor)
    );
    const apmMiddleware = app.get(APM_MIDDLEWARE);
    app.use(apmMiddleware);
  }

  globalInterceptors.push(
    new TimeoutInterceptor()
  );
  app.useGlobalInterceptors(... globalInterceptors);

  const port = configService.get<number>('PORT') || 3000;
  app.startAllMicroservicesAsync();

  await app.listen(port, () => winstonLogger.log(`Hybrid sample-project test running on port ${port}`));

}
bootstrap();

As you can see, we start configuring the APM agent for sending data to APM. This is one of the tools we use for gathering metrics of our services.

We also use Winston for logging. That's why we instantiate the logger in the first place and pass it to the nest factory.

Then we add a global interceptor and a global filter. If we are in production, we finish setting up APM and pusing the interceptors.

The filter we are using is for catching all exceptions that occurs in the app.

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost): void {
    const ctx = host.switchToHttp();
    const request = ctx.getRequest();
    const response = ctx.getResponse();

    let status = 500;

    if(exception instanceof HttpException) {
      status = exception.getStatus();
    }

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

You can see that the filter just catches the exceptions and returns a standard response.

On the other hand, the timeout interceptor just acts on every message sent and if it takes more than 5 seconds to resolve, it throws an exception.

If you choose a pure app, the code is almost the same. But we don't have to define any port and the metadata interceptor can be used also as a global one.

app.*.ts

The app.*.ts files contains the main module code.

app.module.ts

@Module({})
export class AppModule {
  public static register(): DynamicModule {
    const imports = [
      MongooseModule.forRootAsync({
        useClass: MongoConfigService,
      }),
      WinstonModule.forRoot(logger.console()),
      ConfigModule.forRoot({
        isGlobal: true,
        validationSchema: JoiObject({
          NODE_ENV: JoiString()
            .valid('development', 'production', 'test')
            .default('development'),
          PORT: JoiNumber().port().default(3030),
          ELASTIC_APM_SERVER_URL: JoiString(),
          ELASTIC_APM_SERVICE_NAME: JoiString(),
          ELASTIC_APM_SECRET_TOKEN: JoiString(),
          NATS_URL: JoiString().required().default('nats://localhost:4222'),
          NATS_USER: JoiString(),
          NATS_PASSWORD: JoiString(),
          MONGODB_URI: JoiString().uri().required(),
          INFLUX_URL: JoiString().uri()
        })
      }),
      MetricsModule,
      MessageModule
    ];

    if(process.env.NODE_ENV === 'production') {
      imports.push(ApmModule.forRootAsync({
        useFactory: async () => {
          return {
            httpUserMapFunction: (req: any) => {
              return {
                ...req
              };
            },
          };
        },
      }));
    }

    const controllers = [AppController];

    const providers = [NATSConfigService, AppService];

    return {
      module: AppModule,
      imports,
      controllers,
      providers,
    };
  }
}

As you can see, we are using a dynamic module. We need to use that because we can register the APM module only in production.

We use joi for validating the config that has to be present in the .env file.

In this case we are using mongoose for persistence but there is an option for choosing also MySQL and PostgreSQL.

We also import two modules, the metrics and message modules.

If you choose a pure app the metrics interceptor is going to be used also as a provider.

If you use a different persistence layer you will see there another different config service injected there. If no persistence chosen, no config service injected.

metrics|message.module.ts

The metrics module is simple and is used with the metrics interceptor. The interceptor is just placed in the middle of every request (http or rpc) and calls the metrics service to send a few data to our metrics infrastructure, influxdb.

@Injectable()
export class MetricsService {
  constructor( private configService: ConfigService) { }

  private influx = new Influx.InfluxDB(this.configService.get<string>('INFLUX_URL') || 'http://localhost:8086/telegraf');

  async send(measurement: string, fields: Record<string, any>): Promise<void> {
    this.influx.writePoints([{
      measurement,
      fields
    }]);
  }
}

It is what it is, a service for sending metrics to influxdb.

Then we have the message module. That module just imports the message service which implements the same functions the NestJS ClientProxy.

@Injectable()
export class MessageService {
  constructor(@Inject('MESSAGE_CLIENT') private client: ClientProxy){};

  sendMessage<Toutput = any, Tinput = any>(pattern: Record<string, any> | string, message: MicroserviceMessage<Tinput>): Observable<Toutput> {
    return this.client.send<Toutput, MicroserviceMessage<Tinput>>(pattern, message);
  }

  emitMessage<Toutput = any, Tinput = any>(pattern: Record<string, any> | string, message: MicroserviceMessage<Tinput>): Observable<Toutput> {
    return this.client.emit<Toutput, MicroserviceMessage<Tinput>>(pattern, message);
  }
}

We use our wrapping functions because we want to centralize the sending of the messages in the same place and if, at some point, we need to implement more metrics, controls or whatever in the sending of messages, we just have to put it in one place.

We also define our own MicroserviceMessage interface which includes, besides the pattern and payload, some metadata we use for logging.

Interceptors

In the project we have 3 interceptors. One for the metrics, one for the metadata and a timeout interceptor. The timeout has already been explained above.

The metadata interceptor is another simple interceptor. It just takes every RPC message, gets the pattern of the message (as we use NATS) and injects it into the message payload. We use this so that, for each request, we can print the metadata of the message with the message pattern that triggered that log line. This allow us to trace (for a specific request ID) every message pattern sent in a user flow.

And the metrics interceptor is just an interceptor to send metrics using the previously seen metric service. It just acts on each request and depending on the request type (HTTP or RPC) gathers different metrics. At the end, it send those metrics to influx using the metrics service.

Example service and controller

We also generate an app.service.ts and an app.controller.ts to illustrate the required configuration for each of them.

@UseInterceptors(MetricsInterceptor, InjectMetadataInterceptor)
@Controller()
export class AppController {
  constructor(
    private readonly appService: AppService,
    private readonly messageService: MessageService,
    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger
  ) { }

  @MessagePattern({ cmd: 'YOUR_CMD' })
  yourMessageHandler(@Payload() message: MicroserviceMessage): Record<string, unknown> {
    this.logger.info(message.data, message.metadata);
    return { data: message.data, metadata: message.metadata };
  }

  @Post()
  async yourPostHandler(
    @Body() body: Record<string, any>,
    @Headers('x-request-id') reqId: string
  ): Promise<unknown> {
    this.logger.info({ body, reqId });
    const response = await this.messageService.sendMessage({ cmd: 'YOUR_CMD' }, { data: body, metadata: { reqId } });
    return (await response.toPromise()).data;
  }

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('/status')
  getStatus(): string {
    return '[OK]';
  }
}

The main things here are the interceptors used. The metrics and metadata interceptors has to be injected here because in an hybrid app, if you use them globally they are going to be triggered only for HTTP requests.

Every other functions are standard controller functions with an example message pattern.

We use the annotation @Headers('x-request-id') reqId: string because we use Kong as gateway and have a plugin set up to assign a unique ID to each request.

If you use a pure app the interceptors are not going to be put there because the can be used globally. Also you will not have the HTTP endpoints.

BONUS TRACK: Generating controllers

As I said, the controllers are different if you are using a pure app or an hybrid one. That's why the template project also supports generating a controller. The questions are really simple and the only difference between a pure app controller or an hybrid app one are the interceptors.

If you use a pure app they won't be injected and if you don't, they will.

Conclusion

As said in the beginning of the post, this is a pave road for our company. I think this is a cool project and can either act as a starting point for someone else's project or be useful for anyone to bootstrap own microservices projects.

Please, feel free to comment if you want me to write another post talking about the technical part of the schematics and how I built this template project.

Also feel free to fill an issue in the project repo if you miss something or even open a pull request.

See you in the next post!!

Building authentication for microservices using NestJS

Ale Sánchez — Sat, 11 Apr 2020 12:55:51 +0000

Before all, the code used in this post can be found at:

What is NestJS? If you already know it you can skip this part. NestJS is a framework for building Node.JS applications. It gives you lots of advantages and tools for making them scalable and performant. One of the best parts is that NestJS has the tools needed for building microservices. You can achieve full transport independence, define messaging patterns as well as other things to make our life easier when developing microservices.

If you're completely new to NestJS I recommend you to read the overview and the authentication technique. And, since we are going to develop a couple of microservices, it's a good idea to read also the microservices part. I know that the read could take you some minutes, but it's worth it. I'll wait here!

I'm going to assume in this post that you already read that, so I can skip some configuration and code that is already present there (and probably better explained 😝).

In this post I'm going to use TypeScript and NPM. But just for the records, NestJS allows any combination of typescript or javascript with npm or yarn.

The NestJS documentation shows how to build an application with the authentication and user management in the same place. What I want to show you is how to build that same thing, but for microservices.

That will involve splitting the auth part from the user management part. And also you should be able to request the auth microservice authentication or authorization for a specific user and from any microservice in your network.

The image shows a simplified architecture without gateways or other things. As you can see, other microservices could be connected to the auth one the same way the user does.

Let's start building our architecture...

Messaging between microservices

NestJS provides us the tools needed to communicate between the microservices using message patterns. Why are message patterns so useful?

Imagine we define a message like { role: 'user', cmd: 'check' } to be handled by a specific function. And now, imagine that in the future we want to upgrade or extend the functionality of that feature. We can add a new { role: 'user', cmd: 'check', type: 'newfeature' } message and the network will automatically redirect the new message to a new function which, inside, can end by sending a { role: 'user', cmd: 'check' } message.

With that approach we can extend our architecture with new features without modifying, stopping or deleting old microservices, just adding new ones.

Defining our messages

So let's elaborate the list of messages and request we are going to use in our architecture. First, what do we want to achieve?

Authenticate a user in the auth service
Retrieve a user by user id from the user service
Authorize logged in users (and check if their login is valid)
Protect a route and make it only available to authorized users

For the first requirement we don't really need a message, because that's going to be done with a POST request. And the request will be:



POST /auth   Body: { username: string, password: string }

For the second requirement we need a message. For retrieving a user we are going to use:



// Pattern:
{ role: 'user', cmd: 'get' }

// Payload:
{ username: string }

And, for checking if a user is authenticated or not:



// Pattern:
{ role: 'auth', cmd: 'check' }

// Payload:
{ jwt: string }

For the last requirement, we are going to define the following route:



GET /greet

That will only be accessible by authenticated users.

Those messages give us a natural split in two different microservices, the auth and the users one. So let's build them!

Auth microservice

First of all we are going to generate our authentication microservice using nest-cli. If you don't have nest-cli installed, install it with:



npm install -g @nestjs/cli

Once the cli is installed, we can generate our microservice with the command:



nest new auth

That command will generate a new empty NestJS project. Now let's install our dependencies.

Auth service dependencies

For this post, we are going to use TCP as transporter and, as shown in the authentication guide, passport. Also we have to install the nest/microservices package. So let's do that them:



cd auth
npm i -S @nestjs/microservices @nestjs/passport @nestjs/jwt passport passport-local passport-jwt bcrypt
npm i --D @types/passport-local @types/passport-jwt @types/bcrypt

Auth service development

With everything installed we can start developing the microservice. The first thing is, as you know, change the main.ts file to make it a hybrid application.

`main.ts`



async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.connectMicroservice({
    transport: Transport.TCP,
    options: {
      host: 'localhost',
      port: 4000
    }
  })

  await app.startAllMicroservicesAsync();
  await app.listen(3000);
  Logger.log('Auth microservice running');
}
bootstrap();

This is a standard bootstrap function. We are using TCP transport for simplicity, but if we want to avoid the need of a service discovery or the anti-pattern of hard-coding other microservices locations (as we are going to do in this post), we should use a message queue (like NATS, Kafka, RabbitMQ...).

Now that we have the main file ready, let's take a look at the AppModule.

`app.module.ts`



@Module({
  imports: [AuthModule],
  controllers: [],
  providers: [],
})
export class AppModule {}

As you can see, we have removed every providers and controllers, because they are going to be inside the AuthModule.

Now we have to define our AuthModule:

`auth/auth.module.ts`



@Module({
  providers: [AuthService]
})
export class AuthModule {}

For now we are going to put only our AuthService as a provider, since we haven't implemented anything else yet. As you may know, we have to implement the user validation function. We are going to do that in our AuthService. This is the first point in which we are going to take advantage of the microservices architeture.

`auth/auth.service.ts`



@Injectable()
export class AuthService {
  constructor(
    @Inject('USER_CLIENT')
    private readonly client: ClientProxy
    private readonly jwtService: JwtService) {}

  async validateUser(username: string, password: string): Promise<any> {
    try {
      const user = await this.client.send({ role: 'user', cmd: 'get' }, { username })
      .pipe(
        timeout(5000), 
        catchError(err => {
        if (err instanceof TimeoutError) {
          return throwError(new RequestTimeoutException());
        }
        return throwError(err);
      }),)
      .toPromise();

      if(compareSync(password, user?.password)) {
        return user;
      }

      return null;
    } catch(e) {
      Logger.log(e);
      throw e;
    }
  }

  async login(user) {
    const payload = { user, sub: user.id};

    return {
      userId: user.id,
      accessToken: this.jwtService.sign(payload)
    };
  }
}

As you can see here, we are introducing new concepts. The login function is the same as in the docs, so no need to explain much, just takes the payload and issues a JWT. We also injected the JwtService the same way the doc does, so let's review validateUser function.

First of all we are sending a message to another microservice. For that we are using the NestJS ClientProxy injectable. That client proxy has to be configured elsewhere (we'll se later), and gives us helper functions to send messages or emit events to other microservices.

The send function is returning an Observable, so we are taking advantage of that and piping it. If the response takes (for whatever reason) more than 5 seconds, we are forcing a timeout error.

If the message is answered correctly, we are going to compare the received user password with the password received in the API request. We use a timing-safe function for comparing the passwords. If it's correct we return the user (successful authentication), otherwise we return null (failed authentication).

But how can we inject and where should we configure the ClientProxy? Of course, in our AuthModule:

`auth/auth.module.ts`



@Module({
  imports: [ClientsModule.register([{
    name: 'USER_CLIENT',
    transport: Transport.TCP,
    options: {
      host: 'localhost',
      port: 4010,
    }
  }]), JwtModule.register({
    secret: 'yoursecret',
    signOptions: { expiresIn: '60s' }
  })]],
  providers: [AuthService]
})
export class AuthModule {}

We imported the ClientsModule configured with the same transport as our microservice but pointing the microservice we want to send messages to (maybe yo want to use the ConfigModule for not having to repeat the configurations).

Please take into account that the name we put in the ClientsModule has to be the same we put in the @Inject decorator. We also added the JwtModule as in the documentation.

The next step is to implement our local and jwt strategies. Since this part is exactly the same as the one in the documentation I'm just going to put the code here but I'm not going to go through it.

`auth/local.strategy.ts`



@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private readonly authService: AuthService) {
    super();
  }

  async validate(username: string, password: string): Promise<any> {
    const user = await this.authService.validateUser(username, password);

    if(!user) {
      throw new UnauthorizedException();
    }

    return user;
  }
}

`auth/jwt.strategy.ts`



export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(configService: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: 'yoursecret'
    });
  }

  async validate(payload) {
    return { id: payload.sub, user: payload.user};
  }
}

Now we have to add the strategy as a provider in our module:

`auth/auth.module.ts`



@Module({
  imports: [ClientsModule.register([{
    name: 'USER_CLIENT',
    transport: Transport.TCP,
    options: {
      host: 'localhost',
      port: 4010,
    }
  }]), JwtModule.register({
    secret: 'yoursecret',
    signOptions: { expiresIn: '60s' }
  })]],
  providers: [AuthService, LocalStrategy, JwtStrategy]
})
export class AuthModule {}

Now the last part is, as in the docs, create our AuthGuard with the local strategy. No explanation needed here:

`auth/local-auth.guard.ts`



@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {}
```

We are not creating the jwt auth guard, because we are going to implement the authorization in a different way.

The last part is to create our `AuthController`:

#### *`auth/auth.controller.ts`*
```typescript
@Controller()
export class AuthController {
  constructor(
    private readonly authService: AuthService) {}

  @UseGuards(LocalAuthGuard)
  @Post('auth')
  async login(@Request() req) {
    return this.authService.login(req.user);
  }
}
```

This part is the same as the one in the documentation. With this controller, our module will look like this:

#### *`auth/auth.module.ts`*
```typescript
@Module({
  imports: [ClientsModule.register([{
    name: 'USER_CLIENT',
    transport: Transport.TCP,
    options: {
      host: 'localhost',
      port: 4010,
    }
  }]), JwtModule.register({
    secret: constants.jwtSecret,
    signOptions: { expiresIn: '60s' }
  })],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy]
})
export class AuthModule {}
```

Let's review what we have until this moment. We have our auth microservice set up accepting a `POST` request to `/auth` for authenticating a user. That endpoint receives a username and a password and gets the user entity from another microservice not built yet. Based on that response is going to compare the passwords and authenticate or not the user. If you run the microservice with `nest start` it should start up, but if you try to make a `POST` request to that service you are going to get a `TimeoutError`. So...

Let's go into our second microservice!

# User microservice

As well as we did with the auth microservice, let's generate the application.

```bash
nest new user
```

## User service dependencies

Let's now install the dependencies. Here we don't need passport or strategies, but we do need some data persistence. We are going to use PostgreSQL as persistence layer and [TypeORM](https://docs.nestjs.com/techniques/database) as orm.

```bash
cd user
npm i -S @nestjs/microservices @nestjs/typeorm bcrypt class-validator pg typeorm
npm i -D @types/bcrypt
```

## User service development

The first step is, again, adapt our `bootstrap` function to the microservices pattern:

### *`main.ts`*
```typescript
async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.connectMicroservice({
    transport: Transport.TCP,
    options: {
      host: 'localhost',
      port: 4010
    }
  });

  app.startAllMicroservicesAsync();
  await app.listen(3010);
}
bootstrap();
```

Same thing as with the auth service, but with different ports. I like to increase port numbers 10 by 10, but it's just a personal way of doing it.

Now that our service is ready to run as an hybrid application, let's create our `UserEntity`. That will be the object that is going to represent (thanks to `TypeORM`) the users in our database:

### *`user/user.entity.ts`*
```typescript
@Entity()
@Unique(['username'])
@Unique(['email'])
export class User implements UserInterface {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @Column()
  @Min(8)
  password: string;

  @Column()
  name: string;

  @Column()
  @IsEmail()
  email: string;

  @CreateDateColumn()
  createdAt: Date;

  @BeforeInsert()
  async hashPassword() {
    this.password = await hash(this.password, 10);
  }
}
```

This is a standard entity representing a standard user with username, password, email and name. We added an autogenerated `createdAt` field and a function that is going to be run before every insertion to hash the password.

> You can import the `hash` function from the `bcrypt` package.

And the `UserInterface` is just:

### *`user/user.interface.ts`*
```typescript
export interface UserInterface {
  id: number
  username: string
  password: string
  name: string
  email: string
}
```

Now we have to build our `AppModule` to set up the `TypeORM` module:

### *`app.module.ts`*
```typescript
@Module({
  imports: [TypeOrmModule.forRoot({
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username: 'ms-user',
    password: 'ms-user-pass',
    database: 'ms-user',
    synchronize: true,
    entities: [User]
  })],
})
export class AppModule { }
```

The `entities` array contains just one, our `UserEntity` previously defined.

> Tip: For running a PostgreSQL server locally I highly recommend you use their official (docker image)[https://hub.docker.com/_/postgres]

With that in place, let's look at our `UsersService`. The one responsible of working with the database and user entities:

### *`user/user.service.ts`*
```typescript
@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>
  ) {}

  findOne(query: FindConditions<User>): Promise<User> {
    return this.userRepository.findOne(query);
  }

  async createUser(user: any): Promise<InsertResult> {
    try {
      /**
       * Perform all needed checks
       */

      const userEntity = this.userRepository.create(user);

      const res = await this.userRepository.insert(userEntity);

      Logger.log('createUser - Created user');

      return res;
    } catch(e) {
      Logger.log(e);
      throw e;
    }
  }
}
```

Nothing special there, just functions for inserting and retrieving users. But let's look at the fun part... The `UserController`.

### *`user/user.controller.ts`*
```typescript
@Controller()
export class UserController {
  constructor(
    private readonly userService: UserService
  ) { }

  @MessagePattern({ role: 'user', cmd: 'get' })
  getUser(data: any): Promise<User> {
    return this.userService.findOne({ username: data.username });
  }
}
```

That starts to look familiar. We just implemented our message pattern for the user microservice. This function must not be protected because our auth microservice needs to ask it for the user trying to authenticate. That function will only check in the database if the user exists and, if exists, will send back to the auth microservice.

So our `UserModule` will look like this:

### *`user/user.module.ts`*
```typescript
@Module({
  imports: [
    TypeOrmModule.forFeature([User]),
  ],
  providers: [UserService],
  controllers: [UserController],
})
export class UserModule {}
```

We have to register again the `TypeOrm` module for the `User` feature and, of course, we have to import this module into our root `AppModule`:

### *`app.module.ts`*
```typescript
@Module({
  imports: [UserModule, TypeOrmModule.forRoot({
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username: 'user',
    password: 'pass',
    database: 'user-microservice',
    synchronize: true,
    entities: [User]
  })],
})
export class AppModule { }
```

Let's summarize again what we have until now!

We built an authentication microservice which accepts a `POST` request with user and password. That microservice asks via message to our user microservice for the details of that user. Compares the user's password and the received password. If they are different, returns an Unauthorized error. If they are the same, it issues a JWT and returns it to the client. Cool, right??

For testing full flow you first have to insert some users to your Postgres database, for example `user1:password`. Now run your microservices:

```bash
cd auth
npm run start:dev
```

And

```bash
cd user
npm run start:dev
```

Now our `POST` request should look like:

```bash
curl --location --request POST 'http://localhost:3000/auth' \
--header 'Content-Type: application/json' \
--data-raw '{
    "username": "user1",
    "password": "password"
}'
```

That request should return you:

```json
{
    "userId": 1,
    "accessToken": "ey..."
}
```

But if you send an incorrect username or password, you should get an Unauthorized error.

# User and auth service together

Ok, you made progress so far, but it seems that there is one more thing missing...

We can now authenticate users, but we also need to authorize them! How can we protect routes in any microservice by using our strategies defined in the auth microservice?

First of all, we need our auth microservice to understand that it needs to handle another type of request, our `check` message pattern. We are going to implement it in our `AuthController`:

#### *`auth/auth.controller.ts`*
```typescript
@Controller()
export class AuthController {
  constructor(
    private readonly authService: AuthService) {}

  @UseGuards(LocalAuthGuard)
  @Post('auth')
  async login(@Request() req) {
    return this.authService.login(req.user);
  }

  @MessagePattern({ role: 'auth', cmd: 'check'})
  async loggedIn(data) {
    try {
      const res = this.authService.validateToken(data.jwt);

      return res;
    } catch(e) {
      Logger.log(e);
      return false;
    }
  }
}
```

We added the `loggedIn` function that is going to handle the `check` message. This function just has to call the one in charge of validating the token. Let's see our `AuthService` with that function implemented.

#### *`AUTH auth/auth.service.ts`*
```typescript
@Injectable()
export class AuthService {
  constructor(
    @Inject('USER_CLIENT')
    private readonly client: ClientProxy,
    private readonly jwtService: JwtService) {}

  async validateUser(username: string, password: string): Promise<any> {
    try {
      const user = await this.client.send({ role: 'user', cmd: 'get' }, { username })
      .pipe(
        timeout(5000), 
        catchError(err => {
        if (err instanceof TimeoutError) {
          return throwError(new RequestTimeoutException());
        }
        return throwError(err);
      }),)
      .toPromise();

      if(compareSync(password, user?.password)) {
        return user;
      }

      return null;
    } catch(e) {
      Logger.log(e);
      throw e;
    }
  }

  async login(user) {
    const payload = { user, sub: user.id};

    return {
      userId: user.id,
      accessToken: this.jwtService.sign(payload)
    };
  }

  validateToken(jwt: string) {
    return this.jwtService.verify(jwt);
  }
}
```

The new function just has to take the JWT received and call the `JwtService` to check whether the token received is valid or not. Simple.

Let's move back again to the user microservice and see how to use that new message pattern to protect routes.

First things firts, let's create a guard for protecting routes. As any guard, it has to have a `canActivate` function. That is the one in charge of asking to the auth service if the JWT is valid:

#### *`USER guards/auth.guard.ts`*
```typescript
export class AuthGuard implements CanActivate {
  constructor(
    @Inject('AUTH_CLIENT')
    private readonly client: ClientProxy
  ) {}

  async canActivate(
    context: ExecutionContext,
  ): Promise<boolean> {
    const req = context.switchToHttp().getRequest();

    try{
      const res = await this.client.send(
        { role: 'auth', cmd: 'check' },
        { jwt: req.headers['authorization']?.split(' ')[1]})
        .pipe(timeout(5000))
        .toPromise<boolean>();

        return res;
    } catch(err) {
      Logger.error(err);
      return false;
    }
  }
}
```

We are injecting a `ClientProxy` to be able to send a message to our auth microservice. That client has to be configured (because we are using TCP) to reach the auth microservice. We'll do that in our `UserModule`.

In the guard we are just getting the request received, extracting the JWT (if present) and sending it to the auth microservice. If we get no response after 5 seconds, we just raise a timeout error. If we do get response, we let the request be processed or not based on that response. Easy!!

Now we just have to create a route and protect it using the `@UseGuard` decorator, and also register the `ClientsModule` for making the `ClientProxy` available in the guard. Let's create, for example, a `greet` route:

#### *`USER user/user.controller.ts`*
```typescript
@Controller()
export class UserController {
  constructor(
    private readonly userService: UserService
  ) { }

  @MessagePattern({ role: 'user', cmd: 'get' })
  getUser(data: any): Promise<User> {
    return this.userService.findOne({ username: data.username });
  }

  @UseGuards(AuthGuard)
  @Get('greet') 
  async greet(): Promise<string> {
    return 'Greetings authenticated user';
  }
}
```

The route is going to return a fixed text, but only if you provide a valid JWT.

And, finally, our `UserModule` has to look like this:

### *`user/user.module.ts`*
```typescript
@Module({
  imports: [
    TypeOrmModule.forFeature([User]),
    ClientsModule.register([{
      name: 'AUTH_CLIENT',
      transport: Transport.TCP,
      options: {
        host: 'localhost',
        port: 4000
      }
    }])
  ],
  providers: [UserService],
  controllers: [UserController],
})
export class UserModule {}
```

Now we can all our login endpoint with valid credentials:

```bash
curl --location --request POST 'http://localhost:3000/auth' \
--header 'Content-Type: application/json' \
--data-raw '{
    "username": "user1",
    "password": "password"
}'
```

To get a valid JWT in the response and, with it, call our brand new `/greet` route:

```bash
curl --location --request GET 'http://localhost:3010/greet' \
--header 'Authorization: Bearer ey...'
```

And we should receive:

```
Greetings authenticated user
```

Instead, if we don't provide a valid JWT:

```bash
curl --location --request GET 'http://localhost:3010/greet' \
--header 'Authorization: This isn't valid'
```

We should receive an error:

```json
{
    "statusCode": 403,
    "message": "Forbidden resource",
    "error": "Forbidden"
}
```

# Conclusions

We have created two different microservices. Each of them is responsible of different sorts of things. The auth microservice is responsible of the authentication and authorization of the users, and the user microservice is responsible of manage them only.

We could add an endpoint for registering new users in the user microservice or add roles based access to the routes in the auth microservice.

The best part of implementing an approach like this is that we can reuse our auth mechanisms in every new microservice we build. But, on the other hand, if we want to work this way we have to be extremely careful and always keep backwards compatibility in our auth microservice.

# Disclaimer

This post has the purpose of illustrating how to implement the authentication/authorization in a microservices environment, but also doing it in an easy way for making the post readable and enjoyable.

I added here some simplifications and omitted important parts regarding security. Please, if you plan to move this to production, read some articles about how to add security to microservices and best practices about storing secrets and sensible data in production (like passwords, jwt secrets and so...)

If you liked it, don't forget to leave a comment! :)

DEV Community: Ale Sánchez

In a stupid defence of human-crafted content

Presenting Assistant Language. A programming language created with GPT3

Let's start simple

Adding functionality to the programming language

Variables

Arithmetic operators

Logic operators

If statement

Comparison operators

Looping

Functions

Utility functions

Interact with the underlying OS

Some advanced features

Naming the language

Wrap it up and provide an interpreter

¿Qué son y cómo funcionan las impresoras 3D?

Impresoras de tinta

Impresoras 3D

Impresoras de filamento

Impresoras de Resina

Aplicaciones

Concurrency or Parallelism? Differentiate them

What is a CPU and how does it work?

So... what is parallelism?

Ok, but what is concurrency?

Conclusion

Depurar Python como un Pro

Qué es depurar

Por qué necesito depurar

Ejemplos de depuración

Depurar en VSCode

Depurar en Jupyter

Depurar Streamlit

Depurar Flask

Conclusiones

6 Cositas sabrosas que hacer con Python

1. Intercambia valores de variables en una sola sentencia

2. Conoce y usa las funciones built-in

3. Usa in para buscar en listas

4. Haz buenas migas con los list comprehensions

5. Usa funciones generadoras para ahorrar memoria

6. Python 3.8 o más: Operador walrus

Recapitulación

Trabajando a 100 por hora en Jupyter Notebook

Qué es Jupyter

¿Por qué modificar lo que viene de base?

Pre-requisitos

Instalar los paquetes

Lo primero es lo primero

Ahora sí, las extensiones

Tree Filter

Table of Contents (2)

Collapsible Headers

Snippets

Initialization Cells

Autopep8

Comment/Uncomment Hotkey

ExecuteTime

Variable Inspector

Hinterland

Scratchpad

Conclusiones

La relación entre una Lambda de Python y los Simpsons

A por las metáforas

¿Qué tiene todo esto que ver con Python?

Cómo se crea un scope en python

Scope local

Envoltura

Global

Incorporado (Built-in)

¿Cómo podemos añadir elementos a un scope?

¿Y qué leches es eso del shadowing?

¿Pero todo esto no iba de una lambda?

¿Cómo solucionarlo?

Cómo modificar el scope

Algunas curiosidades de Python

El scope en los bucles

El scope en los bloques if

3. Usa `in` para buscar en listas

`main.ts`

`app.module.ts`

`auth/auth.module.ts`

`auth/auth.service.ts`

`auth/auth.module.ts`

`auth/local.strategy.ts`

`auth/jwt.strategy.ts`

`auth/auth.module.ts`

`auth/local-auth.guard.ts`