DEV Community: Juan Miguel Arias Mejias

El origen de la historia

Juan Miguel Arias Mejias — Sat, 04 Jan 2025 01:14:34 +0000

¿Primer encuentro con código?
Creo que mi primer acercamiento al código ocurrió viendo películas, especialmente aquellas en las que aparecían hackers. Fue hace tanto tiempo que no recuerdo un evento específico, pero sí sé que las escenas con computadoras me parecían fascinantes. Esa curiosidad inicial despertó mi interés por explorar todo lo que se podía hacer con una computadora.

En ese entonces, teníamos una computadora en casa, que usaba casi exclusivamente para jugar. Mis favoritos eran Age of Empires, Warcraft, y un juego de motos cuyo nombre no logro recordar.

¿Qué te atrajo de la tecnología?
Lo que más me atrajo fue la posibilidad de crear y mejorar la vida de las personas. La capacidad de automatizar procesos tediosos o complicados me pareció algo increíblemente poderoso. Saber que puedes usar la tecnología para resolver problemas reales y aliviar cargas me motivó aún más.

¿Quién te inspiró?
Curiosamente, quien me impulsó a decidirme por la informática fue un profesor de música. Me aconsejó elegir una profesión en la que pudiera dedicar muchas horas sin agotarme. Pensé en cuánto tiempo podía pasar frente a una computadora sin cansarme y me dije: "Esto es para mí".

Una vez que empecé la carrera, descubrí que realmente me gustaba y que se me daba bien. Así que, aquí estoy, disfrutando del camino que tomé gracias a esa pequeña conversación.

Builder pattern / improvements

Juan Miguel Arias Mejias — Mon, 15 Apr 2024 02:19:32 +0000

Hi everyone,

Today, I want to delve into the Builder pattern—an essential design concept that many developers encounter at some point in their careers. This pattern significantly enhances our ability to construct complex objects in a controlled and scalable manner. However, there's always room for improvement, especially in how we manage the construction process.

Understanding the Builder Pattern

The Builder pattern simplifies the creation of complex objects by breaking down the construction process into discrete, manageable steps, handled by a director and a builder. The director controls the order of building steps, while different builders implement the specific details of the object being constructed. Here’s a basic example using a house construction analogy:

package main

type Director struct {
    builder IHouseBuilder
}

func newDirector(b IHouseBuilder) *Director {
    return &Director{
        builder: b,
    }
}

func (d *Director) setBuilder(b IHouseBuilder) {
    d.builder = b
}

func (d *Director) buildHouse() House {
    d.builder.setDoors()
    d.builder.setWindows()
    d.builder.setRooms()
    return d.builder.getHouse()
}

In this snippet, the Director is tasked with building a house by sequentially initiating the construction of doors, windows, and rooms through the builder. This step-by-step approach ensures that each component is completed before the next begins, traditionally taking about 3 seconds for our hypothetical build.

Optimizing with Concurrency

What if we could speed up this process? Instead of constructing each component sequentially, we could leverage concurrency to handle these tasks simultaneously, significantly reducing build time.

package main

import "golang.org/x/sync/errgroup"

type Director struct {
    builder IHouseBuilder
}

func newDirector(b IHouseBuilder) *Director {
    return &Director{
        builder: b,
    }
}

func (d *Director) setBuilder(b IHouseBuilder) {
    d.builder = b
}

func (d *Director) buildHouse() (House, error) {
    var eg errgroup.Group

    eg.Go(d.builder.setDoors)
    eg.Go(d.builder.setWindows)
    eg.Go(d.builder.setRooms)
    if err := eg.Wait(); err != nil {
        return House{}, err
    }
    return d.builder.getHouse(), nil
}

By using Go’s errgroup package, we can parallelize the construction steps. This alteration allows the building of doors, windows, and rooms to occur simultaneously, potentially cutting down the total build time to approximately 1 second—a significant improvement!

The Impact of Concurrency

Implementing concurrency in your Builder pattern can dramatically enhance efficiency, especially in languages like Go that are designed with concurrency in mind. This method ensures that the end result remains consistent while optimizing the construction process.

Resources and Further Exploration

If you're interested in experimenting with these concepts, you can access the complete code examples here:

Feel free to follow me on Instagram @i.am.juan.dev for more insights and updates on software development practices.

I encourage you to explore the potential of integrating concurrency into your Builder implementations. It’s a powerful way to enhance performance and efficiency in your projects. Happy coding!

Factory Method

Juan Miguel Arias Mejias — Sun, 10 Apr 2022 21:25:41 +0000

Hola, hoy venimos con un patrón de diseño creacional.

El Factory Method, es un patrón que nace de la necesidad de abstraer la lógica de creación de un objeto. Es más fácil entenderlo con un ejemplo.

Pongamos en situación que estamos dándole mantenimiento a un sistema de logística, en donde el método de entrega siempre ha sido por tierra y todo bien, el sistema funciona de esta manera por varios años sin problemas. Llega el día, en que nuestra empresa decide diversificar las operación y se toma la decisión de ofrecer logística marítima.

Vaya... parece que tenemos un problema, el sistema solamente esta enfocado a logística terrestre ¿Cómo haremos para resolver este problema? y sobre todo, ¿Cómo haremos para mejorar la escalabilidad del sistema? de manera que puedan haber tantos métodos de logística como se quiera sin mayores modificaciones.

El Factory Method, nos puede ayudar en esta ocasión, es un patrón de diseño creacional listo para abstraer la lógica de la creación.

Ok, estamos listos para implementarlo.

En este caso, necesitamos pensar en cómo llamaremos de manera general al grupo que envuelve el camión o el bote. Quizás Transporte.

También necesitamos pensar en cómo llamaremos de manera general al grupo que envuelve la logística Terrestre y el Marítima. Quizás Logística.

Estamos listos.

Por la parte del Transporte tendríamos el siguiente diagrama:

Y por la parte de Logística tendríamos el siguiente:

En mi GitHub podrán ver la implementación en Golang. Enlace
Muchas gracias por leer
Les dejo mis redes: Enlace

Imágenes y ejemplo tomado de: Enlace

Estructura de datos: Pila

Juan Miguel Arias Mejias — Wed, 06 Apr 2022 03:17:32 +0000

Hola! Soy yo de nuevo

En esta ocasión venimos a escribir sobre la estructura de datos pila.

La pila o "stack" del ingles, es la contra parte de la cola(te recomiendo que leas el articulo anterior), se describe así: El primer dato que entra es el último en salir o el último dato que ingresa es el primero en salir.

Lo podemos ver de esta forma. Cuando tenemos una pila de platos sucios, los apilamos, en espera de ser lavados. Cuando colocamos solamente uno, se vería de la siguiente forma:

1 - Plato sucio -

Como no hemos estado atentos a la pileta, de repente ingresan 2 platos sucios a la vez ¡Y no hemos procesado ni uno!

3 - Plato sucio - 2 - Plato sucio - 1 - Plato sucio -

Deberíamos de ponernos a ello y empezar a limpiarlos, en esta ocasión siguiendo el algoritmo de pila, el cuál nos dice que el último plato sucio que haya sido ingresado es el primero que debo de lavar. ¡Pues a trabajar!

- / - Sonidos de limpieza - / -

Listo, hemos lavado uno ¿Cómo se ve nuestra pila ahora?

2 - Plato sucio - 1 - Plato sucio -

Lavemos otro!

- / - Sonidos de limpieza - / -

¡Ufff, qué trabajo más arduo! Debería de solamente quedarnos un plato sucio pendiente, y según el algoritmo de pila, debería de quedarnos el primer plato que ingresó.

1 - Plato sucio -

Efectivamente, el plato pendiente es el primero que ingresó a la pila. Bueno, será momento de lavarlo, nadie lo hará por nosotros.

- / - Sonidos de limpieza - / -

¡Te felicito de haber llegado aquí! Has sido capaz de lavar toda la pila, vaya logro.

Por acá te dejo el vídeo tutorial de la implementación en Golang: https://www.youtube.com/watch?v=IDNc_qb5110

Además te dejo el repositorio: https://github.com/juanmiguelar/Stack-golang

Y por si fuera poco, te dejo mis redes:
https://linkr.bio/juanmiguelar

Gracias por leer
Pasa bonita vida

Estructura de datos: Cola

Juan Miguel Arias Mejias — Mon, 04 Apr 2022 01:52:48 +0000

Hola!

Hace un tiempo no escribo en este portal. Me gustaría regresar con un tema fundamental de la programación, estructuras de datos.

Las estructuras de datos son simplemente, formas diferentes de organizar los datos. Estas surgen de la necesidad de resolver problemas que son muy comunes o repetitivos en la labor del programador.

Vamos a centrarnos en la cola o "queue" del ingles.

La Cola, es una estructura de datos que se comporta de forma similar a una cola o fila en el banco, tomando en cuenta que en esta analogía, los datos son las personas, que llegan para ser atendidas.

Si la fila del banco esta vacía y llega una persona, pues lo más normal es que la primera persona que llegue sea la primera persona en ser atendida. Este es el principio fundamental de las colas. Primero que entra primero que sale. Primer dato que ingresa a la cola, primer dato que sale.

Digamos entonces, nuestra cola va a ser representada por una colección, de la siguiente forma:

[]

Si viene un dato a la cola, un dato que queremos encolar, por ejemplo un numero, se vería de la siguiente forma:

[1]

Y si este proceso se repite algunas veces:

[1, 2, 3]

Tenemos una colección de 3 ítems, que se han colado haciendo fila para ser procesados, en el momento que quiera procesar los datos, debo desencolar uno. En esta ocasión al hacerlo, debería de salir el primer dato que haya sido ingresado, de la siguiente forma:

[2, 3]

Como podemos notar, el primer dato que ingresó fue el número 1 y este ha sido el primero que ha salido. Si repetimos el proceso, quedaría de la siguiente forma nuestra cola:

[3]

De nuevo, se ve cómo es que el último que ingresó a la cola es el último en ser atendido.

Si te animas a implementar este comportamiento de cola, te animo a checar el video tutorial que he creado en Youtube.
Implementación de cola en golang

Gracias por leerme, Juan Miguel Arias Mejías

Te dejo mis redes: enlace
Pasa bonita vida.

Detectar imágenes con inteligencia artificial

Juan Miguel Arias Mejias — Sun, 23 May 2021 22:44:09 +0000

Hola, soy Juan Miguel!

Quisiera iniciar mis entradas en este blog con uno de los temas que más me atraen, la inteligencia artificial.

Les advierto, para realizar este tutorial es necesario contar con conocimientos básicos en python y github.

Iniciemos!

Primero el problema: se nos presenta un requerimiento de reconocer el contenido de un conjunto de imágenes ingresadas por un usuario.

¿Cómo podríamos hacer esto?

Pues, si somos programadores muy avanzados quizás podríamos realizar el algoritmo para reconocer el contenido de las imágenes, pero gracias a la maravillosa comunidad de desarrolladores de software, esto no es necesario. Existe ImageAI!

ImageAI

Herramienta perfecta para el reconocimiento de imágenes y por supuesto, gratis para probarla y jugar con ella. Vamos a ello!

Tengo preparado un repositorio listo! Va a ser increíblemente sencillo, créeme; Link al repo

¿Qué podremos encontrar en el repositorio?

brain.py: Archivo de python listo para probarse.
giraffe.jpg, godzilla.jpg, house.jpg: Imágenes para probar
mobilenet_v2.h5: A este archivo, quizás podríamos llamarle la inteligencia.

Cuando descarguemos este repositorio necesitamos ejecutar los siguientes comandos para poder correr el brain.py:

pip install tensorflow==2.4.0
pip install imageai --upgrade

Debemos tomar en cuenta que la inteligencia que estamos utilizando en este tutorial no es muy avanzada, pero aqui les dejo el enlace para que prueben con otras más precisas.

Les dejo un vídeo para guiarles en todo el proceso.

Un saludo!

LinkedIn
Github