domingo, 16 de febrero de 2025

Determinar el biotipo de una persona en C

En una pasada entrega vimos cómo calcular el biotipo de una persona en Java. Ahora lo haremos usando el lenguaje de programación C.

Pero, ¿Qué es el biotipo de una persona?

Es la forma característica de un animal o planta. Es el aspecto general de un sujeto de acuerdo a sus características somáticas o morfológicas y se basa en los datos que refleja su estructura corporal, en todo lo que se ve y se puede medir de su cuerpo.

Se refiere a las características corporales, como la estructura ósea, la musculatura y la predisposición al metabolismo, que influyen en la salud, el rendimiento físico y la respuesta a la dieta o ejercicio.

Establece que hay una relación entre las características físicas y la personalidad. Esto ya lo habiamos mencionado en la entrega pasada.

Para el programa en C:

  1. Crearemos un archivo de encabezado: biotipo.h 
  2. Un archivo donde tendremos las funciones necesarias para los cálculos: biotipo.c 
  3. Un programa main: main.c

Existen varios biotipos, pero el general comprende estos tres:

  • Ectomorfo: Cuerpo delgado, extremidades largas, dificultad para ganar peso o masa muscular, metabolismo rápido. En otras palabras, sería Longitipo
  •  Mesomorfo: Cuerpo atlético, facilidad para ganar músculo, estructura ósea equilibrada, metabolismo eficiente. En otras palabras, sería Normotipo.
  •  Endomorfo: Cuerpo con mayor tendencia a acumular grasa, estructura más ancha, metabolismo más lento. En otras palabras, sería Braquitipo.

El programa comprenderá dos "hashmap", hechos con estructuras. Uno para los pesos y el otro para las estaturas.

biotipos.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Estructura para simular el HashMap (clave-valor)
typedef struct {
    char *clave;
    double valor;
} ParClaveValor;

// Listas de pares clave-valor para peso y estatura
ParClaveValor mapaPeso[] = {
    {"85.54", 3.0}, {"83.79", 2.75}, {"82.04", 2.5}, {"80.29", 2.25},
    {"78.54", 2.0}, {"76.79", 1.75}, {"75.04", 1.5}, {"73.29", 1.25},
    {"71.54", 1.0}, {"69.79", 0.75}, {"68.04", 0.50}, {"66.29", 0.25},
    {"64.54", 0.0}, {"62.79", -0.25}, {"61.04", -0.50}, {"59.29", -0.75},
    {"57.54", -1.0}, {"55.79", -1.25}, {"54.04", -1.50}, {"52.29", -1.75},
    {"50.54", -2.0}, {"45.79", -2.25}, {"47.04", -2.5}, {"45.29", -2.75},
    {"43.54", -3.0}
};

ParClaveValor mapaEstatura[] = {
    {"1.87", 3.0}, {"1.86", 2.75}, {"1.85", 2.50}, {"1.83", 2.23},
    {"1.82", 2.0}, {"1.81", 1.75}, {"1.79", 1.50}, {"1.78", 2.25},
    {"1.77", 1.0}, {"1.75", 0.75}, {"1.74", 0.50}, {"1.73", 0.25},
    {"1.71", 0.0}, {"1.7", -0.25}, {"1.69", -0.50}, {"1.67", -0.75},
    {"1.66", -1.0}, {"1.65", -1.25}, {"1.63", -1.50}, {"1.62", -1.75},
    {"1.61", -2.0}, {"1.59", -2.25}, {"1.58", -2.50}, {"1.57", -2.75},
    {"1.55", -3.0}
};

// Tamaños de los mapas
const int TAMANO_PESO = sizeof(mapaPeso) / sizeof(mapaPeso[0]);
const int TAMANO_ESTATURA = sizeof(mapaEstatura) / sizeof(mapaEstatura[0]);

// Función para buscar el valor asociado a una clave en el mapa
double buscarValor(ParClaveValor mapa[], int tamano, const char *clave) {
    for (int i = 0; i < tamano; i++) {
        if (strcmp(mapa[i].clave, clave) == 0) {
            return mapa[i].valor;
        }
    }
    return -999.0; // Valor por defecto si no se encuentra la clave
}

// Función para obtener el peso (equivalente a getPeso en Java)
double obtenerPeso(const char *peso) {
    return buscarValor(mapaPeso, TAMANO_PESO, peso);
}

// Función para obtener la estatura (equivalente a getTalla en Java)
double obtenerEstatura(const char *estatura) {
    return buscarValor(mapaEstatura, TAMANO_ESTATURA, estatura);
}

int main() {
    char peso[10], estatura[10];
    double valorPeso, valorEstatura, desviacion;

    // Solicitar entrada al usuario
    printf("Tu peso es de (ejemplo: 56.00): ");
    fgets(peso, sizeof(peso), stdin);
    peso[strcspn(peso, "\n")] = 0; // Eliminar el salto de línea

    printf("Tu estatura es de (ejemplo: 1.55): ");
    fgets(estatura, sizeof(estatura), stdin);
    estatura[strcspn(estatura, "\n")] = 0; // Eliminar el salto de línea

    // Obtener los valores asociados a peso y estatura
    valorPeso = obtenerPeso(peso);
    valorEstatura = obtenerEstatura(estatura);

    printf("valor peso: %.1f\n", valorPeso);
    printf("valor estatura: %.1f\n", valorEstatura);
    // Verificar si se encontraron los valores
    if (valorPeso == -999.0 || valorEstatura == -999.0) {
        printf("Error: Peso o estatura no válidos. Asegúrate de ingresar valores dentro del rango permitido.\n");
        return 1;
    }

    // Calcular la desviación
    desviacion = valorPeso - valorEstatura;

    // Determinar el biotipo y mostrar el resultado
    if (desviacion < 0) {
        printf("Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil. \n");
    } else if (desviacion > 0) {
        printf("Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.\n");
    } else {
        printf("Tu biotipo es: normotipo. Fuerte. Atlético. Musculoso\n");
    }

    return 0;
}

Compilación y ejecución:

$ gcc -o biotipos.exe biotipos.c
$ ./biotipos.exe

Salida:

Tu peso es de (ejemplo: 56.00): 43.54
Tu estatura es de (ejemplo: 1.55): 1.61
valor peso: -3.0
valor estatura: -2.0
Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil.

El programa requiere ciertos ajustes para permitir otras entradas de estatura y peso.

Enlaces:

https://codemonkeyjunior.blogspot.com/2013/03/determinar-el-biotipo-de-una-persona-en.html

domingo, 2 de febrero de 2025

Utiliza la IA DeepSeek en local con Ollama + Docker (Youtube)

En este vídeo nos enseñan como ejecutar DeepSeek (esa I.A. que ha "desplazado" al otrora rey ChatGPT) de manera local.

Pero, antes que nada, deberías saber algunos conceptos.

¿Qué es Ollana y para qué sirve?

Ollama es una plataforma de código abierto diseñada para ejecutar modelos de lenguaje (LLMs) de manera local en tu ordenador.

Su principal función es permitir a los usuarios descargar, instalar y utilizar estos modelos de inteligencia artificial sin necesidad de depender de servicios en la nube.

Para empezar con Ollama, los usuarios deben descargarlo de su sitio web oficial, compatible actualmente con macOS y Linux, y seguir las instrucciones de instalación para su sistema operativo.

Una vez instalado, se pueden descargar y ejecutar diferentes modelos desde una biblioteca disponible, lo que permite una amplia gama de experimentos y aplicaciones en inteligencia artificial.

Ollama puede ser utilizado para tareas como:

  • Automatización de tareas repetitivas. 
  • Generación y análisis de texto. 
  • Traducción automática. 
  • Respuestas a consultas en sistemas de búsqueda.

Esperemos que te sirva este mini tutorial hecho por @josemarialabarta en su canal de Youtube.

Enlaces:

https://chat.deepseek.com/
https://ollama.com/
https://aws.amazon.com/es/what-is/large-language-model/

Diferencias entre Docker y Kubernetes

Debemos aclarar que:

Docker es una herramienta para crear y gestionar contenedores.

  • Una plataforma de contenerización. 
  • Empaqueta aplicaciones y dependencias en contenedores. 
  • Garantiza la portabilidad entre entornos. 
  • Ejecuta contenedores en un solo host. 
  • Se utiliza en procesos de CI/CD para la automatización de la implementación.

Pero, ¿Qué diantres es un contenedor? Digamos, en términos simples y sencillos:

Es como una pequeña casa portátil para un programa. Tendrá todo lo necesario para ejecutar un programa en otra máquina. Sin tener que preocuparse por la configuración de la misma.

Si solo vas a usar contenedores, con Docker es más que suficiente.

Si requieres algo más como escalabilidad, tendrás que usar Kubernetes.

Kubernetes, por su parte, nos ayuda a gestionar contenedores en producción.

  • Es un sistema de orquestación de contenedores. 
  • Gestiona aplicaciones en contenedores a escala. 
  • Maneja la implementación, el escalamiento y la red. 
  • Distribuye cargas de trabajo entre múltiples nodos. 
  • Optimizado para microservicios y aplicaciones nativas de la nube.

Con Docker podemos crear y ejecutar contenedores y con Kubernetes podremos organizar y administrar esos contenedores a escala. Ambos, Docker & Kubernetes, permiten flujos de trabajo escalables y resilientes de computación en la nube y DevOps.

Enlaces:

https://x.com/HeyNina101/status/1885951537525985333

domingo, 26 de enero de 2025

Devops: una filosofía de trabajo

Devops es una filosofía y un marco de trabajo que combina el desarrollo (Dev) y las operaciones (Ops) de software.

Su objetivo es alcanzar la mejor calidad del software.

Algunas de las metodologías que se usan son:

  1. Kanban: basada en asignación de roles y tableros.
  2. Scrum: una metodología basada en Sprints.
  3. Agile: un enfoque de gestión de proyectos de manera flexible.

Devops implica:

  • Una amplia colaboración de todos los equipos involucrados en un proyecto. 
  • La utilización de herramientas de automatización (Ej. Jenkins). 
  • La recopilación de datos de telemetría. 
  • Donde el cliente esta involucrado y es una parte esencial del equipo.
  • Diseño de pruebas y calidad de software.

Quien desee adentrarse al mundo del Devops tendrán que saber tanto de metodologías ágiles como de herramientas de automatización y pruebas.

Algunas herramientas que tendrá que usar y conocimientos necesarios son:

  • Ansible, para la automatización de la configuración de infraestructura.
  • Docker, para la contenedorización para consistencia entre entornos.
  • Jenkins, para automatización de builds, pruebas y despliegues
  • Kubernetes, para la orquestación de contenedores para escalabilidad y gestión.
  • Terraform, para definir y provisionar infraestructura de manera programática.
  • Conocimiento de Cloud Computing (AWS. Azure, GCP).
  • Manejo de repositorios de código.
  • Etc.

El desarrollador de software tendrá que cambiar su perpectiva y filosofía de trabajo para poder involucarse en el Devops.

Esos años de estar escribiendo código en un cubículo y apartado de todo el equipo involucado en la entrega de un proyecto ha quedado atrás. Quien ose permanecer en el pasado no podrá adentrarse al mundo del Devops.

Enlaces:

https://grupoaspasia.com/es/glosario/metodologia-kanban/
https://ausum.cloud/scrum-metodologia-agil-mas-popular-en-empresas/

jueves, 23 de enero de 2025

GCP: Crear un archivo CSV a partir de una consulta en BigQuery

En esta ocasión veremos como crear un archivo CSV a partir del resultado de una consulta en GCP BigQuery.

¿Qué haremos?

  1. Crearemos una tabla temporal. 
  2. Consultaremos una tabla de la cual queremos los datos.
  3. Con los datos obtenidos crearemos un archivo CSV.

¿Qué es una tabla temporal en BigQuery?

Es una tabla creada temporalmente. Nos servirá como pivote para obtener ciertos datos de una consulta.

¿Cómo exportamos datos en BigQuery?

Usaremos la siguiente sentencia para exportar datos:

EXPORT DATA

El código es el siguiente:

CREATE OR REPLACE PROCEDURE `myproject.mydataset.create_file_csv`(input_fecha STRING)
BEGIN
  -- Crear una tabla temporal con los datos de la consulta
  CREATE TEMP TABLE temp_table AS
  SELECT * FROM `myproject.mydataset.Informe`
  WHERE fecha = CAST(input_fecha AS DATE);

  -- Exportar la tabla temporal a un archivo CSV en GCS, ya que BigQuery no soporta TXT directamente
  EXPORT DATA OPTIONS(
    uri='gs://your_bucket/path/to/file*.csv',
    format='CSV',
    overwrite=true,
    header=true
  ) AS
  SELECT * FROM temp_table;

END;

Para invocar el SP:

CALL `myproject.mydataset.create_file_csv`('2025-01-23');

Tendremos que ir a nuestro Bucket para comprobar que el archivo se ha creado.

En próximas entregas continuaremos con este tema.

Enlaces:

https://cloud.google.com/bigquery/docs/exporting-data

martes, 14 de enero de 2025

Kubernetes como si le explicarás a tu mascota (o a un niño de cinco años)

Kubernetes explicado en términos sencillos:

"Supongamos que tienes muchos juguetes, como carritos, muñecas y bloques. Si los dejas todos tirados, sería un desastre, ¿verdad? Kubernetes es como un amigo mágico que ayuda a ordenar todos tus juguetes".

  1. Organiza: Te ayuda a poner todos los juguetes en grupos. Por ejemplo, todos los carritos juntos, todas las muñecas en otro lugar. 
  2. Mantiene el orden: Si un juguete se rompe o se pierde, Kubernetes puede sacar otro del mismo tipo para que sigas jugando sin problemas. 
  3. Comparte: Si tienes amigos jugando contigo, Kubernetes asegura que todos tengan los juguetes que necesitan, sin que nadie se quede sin nada.

Así que, Kubernetes es como un super organizador que hace que jugar con muchos juguetes sea divertido y sin enredos

"Piensa en Kubernetes como un gerente muy eficiente de una gran empresa, pero en lugar de empleados, maneja aplicaciones y servicios en computadoras".

Imagina que tienes una tienda con muchas sucursales. Cada sucursal necesita tener ciertos productos (aplicaciones) en stock y funcionando bien:

  1. Organización: Kubernetes se asegura de que cada sucursal tenga los productos correctos. Si una sucursal necesita más de un producto específico, Kubernetes lo distribuye automáticamente.
  2. Mantenimiento: Si algún producto no funciona bien en una sucursal, Kubernetes lo reemplaza o repara sin que tú tengas que intervenir directamente. Así, tus clientes siempre tienen lo que necesitan sin interrupciones. 
  3. Escalabilidad: Si de repente hay mucha demanda en una sucursal, Kubernetes puede aumentar rápidamente el número de productos disponibles sin que tengas que preocuparte por la logística.

En resumen, Kubernetes es un sistema que automatiza la gestión, distribución y mantenimiento de aplicaciones en múltiples computadoras, asegurándose de que todo funcione sin problemas, incluso cuando la demanda cambia.

Relación con Docker

Piensa en Docker y Kubernetes como dos partes de un equipo que trabajan juntas para hacer más fácil la gestión de aplicaciones.

"Docker es como una caja mágica para empacar tus cosas. Imagina que cada aplicación es un juguete y Docker te permite meter cada juguete en su propia caja especial (un contenedor). Esta caja asegura que el juguete funcione de la misma manera, sin importar en qué lugar lo saques. Así, puedes mover tus aplicaciones de una computadora a otra sin problemas".

"Kubernetes, por otro lado, es el gerente que organiza todas esas cajas (contenedores de Docker). Si tienes muchas cajas, Kubernetes se encarga de:

  • Colocarlas en los estantes correctos (las computadoras adecuadas). 
  • Mantenerlas en orden, asegurándose de que siempre haya cajas disponibles si una se rompe o si necesitas más. 
  • Distribuir las cajas según la necesidad, si una área necesita más de cierto tipo de juguete, Kubernetes lo maneja.

En resumen, Docker es para empaquetar y asegurar que tus aplicaciones funcionen de manera consistente, mientras que Kubernetes es para gestionar y escalar esos paquetes de manera eficiente en múltiples computadoras.

Ambos trabajan juntos para que la tecnología detrás de las aplicaciones sea más manejable y menos complicada para ti.

Enlaces:

https://kubernetes.io/es/docs/concepts/overview/what-is-kubernetes/

domingo, 12 de enero de 2025

Docker en palabras sencillas

En pasados post ya hemos hablado algo sobre Docker:

¿Qué es Docker?

Es como una caja que guarda tu aplicación con todo lo necesario para ejecutarse en cualquier otra máquina.

Es decir, es una caja donde se empaquetan las configuraciones, librerías, etc. de tu aplicación (Java, Go, Python, Node JS, etc.). Esta caja podrá ser "abierta" en otra máquina y podrá ejecutar tu aplicación sin tener que instalar y/o configurar absolutamente nada.

Similar a lo que hacíamos anteriormente en una Máquina Virtual. De hecho, Docker las ha venido reemplazando.

Mientras que una Máquina Virtual necesita su propio sistema operativo, tarda minutos en arrancar, consume muchos recursos de memoria RAM y espacio en el disco, Docker es más ligero, consume pocos recursos, arranca en segundos y usa el núcleo del sistema host.

Podríamos decir que: Docker es una especie de Máquina Virtual mejorada.

Preguntando a Grok, nos dice:

"Imagina que Docker es como una caja mágica. Dentro de esa caja, puedes poner todo lo que necesita un programa para funcionar, como sus juguetes y herramientas favoritas".

"Cuando cierras la caja, puedes llevarla a cualquier lugar, y al abrirla, el programa funcionará exactamente igual que en casa, sin importar dónde estés. Así que, con Docker, puedes mover programas de un lugar a otro sin que se rompan o se porten mal".

¿Qué es un contenedor?

Un contenedor en Docker es como una pequeña casa portátil para un programa.

"Imagina que tienes un juguete que necesita una casa especial para vivir. Esta casa tiene todo lo que necesita el juguete: su cama, su comida, y sus juegos".

"Cuando metes el juguete en su casa portátil, puedes llevarlo a cualquier parte, y siempre estará feliz porque tiene todo lo que necesita dentro de su casa. Así es un contenedor; es una casa pequeña y especial donde tu programa vive y puede funcionar en cualquier lugar al que lo lleves".

¿Dónde se guardan los contenedores?

Se almacenan repositorios, ya sean públicos y/o privados.

Un ejemplo es Docker Hub.

Los contenedores y las imágenes se almacenan dentro del sistema de archivos de la máquina virtual que Docker Desktop utiliza.

Se gestionan y organizan gracias al demonio (un programa que se ejecuta en segundo plano) de Docker.

Preguntando a Grok, nos dice:

"Los contenedores se guardan en un lugar especial en tu computadora, que podemos imaginar como un gran parque de juegos".

"Piensa en tu computadora como un parque enorme. En este parque, hay un área especial donde están todas las casitas de juguetes (los contenedores)". "Cuando no estás jugando con una casita, la dejas en este parque, donde está segura y lista para que la uses cuando quieras".

"Así que, los contenedores se guardan en una parte de tu computadora reservada solo para ellos, donde pueden esperar hasta que decidas usarlos de nuevo".

Un contenedor en Docker puede tener:

  • Imagen.
  • Volúmenes.
  •  Redes.

¿Qué es una Imagen?

Una imagen en Docker es como un libro de instrucciones para construir una casa de juguetes.

"Imagina que quieres construir una casa para tu juguete. Antes de empezar, necesitas un libro que te diga exactamente cómo hacer la casa, con todos los detalles: qué materiales usar, cómo poner las paredes, el techo, y hasta dónde irán las ventanas".

Una imagen en Docker es exactamente eso, pero para programas. Es un libro de instrucciones que tiene todo lo necesario para crear una casa portátil (un contenedor) para tu programa. Cada vez que quieras hacer una nueva casa igual, solo sigues las instrucciones del libro, y ¡listo! Tienes una nueva casa para tu programa.

Una imagen, por lo tanto, tendrá el sistema operativo base, las dependencias y todo lo que tu aplicación necesita para trabajar.

Instalando Erlang con Docker

Instalamos una imagen de Erlang con Docker:

$ docker pull erlang

Listamos la imagen descargada:

$ docker images -a

Ejecutamos el REPL de Erlang:

$ docker run -it --rm erlang

Creamos un programa en Erlang.

holamundo.erl

% Hola mundo en Erlang
-module(holamundo).
-export([main/1]).

main(_Args) ->
    io:format("Hola, mundo!!~n").

Para ejecutar un script de Erlang:

$ docker run -it --rm --name erlang-inst1 -v "$PWD":/usr/src/myapp -w /usr/src/myapp erlang escript holamundo.erl

Hemos visto lo que es Docker y un ejemplo de como descargar una imagen (de Erlang).

En próximas entregas continuaremos con el tema.

Enlaces:

https://codemonkeyjunior.wordpress.com/2020/09/06/docker-instalando-imagen-de-php/
https://alquimistadecodigo.blogspot.com/2021/06/docker-aclarando-cosas.html
https://hub.docker.com/_/php
https://stackoverflow.com/questions/16047306/how-is-docker-different-from-a-virtual-machine