A continuación se describe seis ejercicios sencillos que abordan los temas de introducción a la programación concurrente, conceptos de programación concurrente, arquitecturas paralelas y distribuidas, así como algoritmos paralelos y distribuidos.

• Escribe un programa en el lenguaje de programación de tu elección que cree dos hilos. Cada hilo debe imprimir un mensaje simple, como “Hola desde Hilo 1” y “Hola desde Hilo 2”.
• Modifica el programa anterior para que ambos hilos intenten acceder y modificar una variable compartida. Utiliza un mecanismo de exclusión mutua (por ejemplo, mutex) para garantizar que solo un hilo pueda modificar la variable a la vez.
• Crea un programa que simule la producción y el consumo de un recurso compartido utilizando monitores. Puedes elegir un escenario simple, como un productor que agrega elementos a un búfer y un consumidor que los retira.
• Diseña un programa que utilice semáforos para sincronizar la ejecución de tres hilos. Cada hilo debe imprimir un mensaje en un orden específico, por ejemplo, “Hilo 1”, “Hilo 2” y “Hilo 3” en ese orden.
• Desarrolla un programa MPI simple en el que un proceso maestro envíe un mensaje a varios procesos esclavos, y estos procesos esclavos respondan al maestro. Puedes usar funciones MPI como MPI_Send y MPI_Recv.
• Implementa un problema clásico de productor-consumidor utilizando hilos y semáforos. El productor debe agregar elementos a un búfer compartido, y el consumidor debe retirarlos. Utiliza semáforos para evitar condiciones de carrera.

Estos ejercicios están diseñados para abordar conceptos básicos en hilos, exclusión mutua, monitores, semáforos y MPI. Se pueden adaptar al lenguaje de programación que se este utilizando.

La entrada Ejercicios | Hilos se publicó primero en Frexus.

Estos ejercicios están diseñados para abordar diversos aspectos, desde la comunicación hasta la coordinación de procesos. Se puede usar cualquier lenguaje de programación.

Ejercicios

• Implementa un programa distribuido donde dos procesos (A y B) se comuniquen enviándose mensajes simples.
• Desarrolla un sistema distribuido que realice una tarea coordinada entre tres procesos, donde cada proceso realiza una parte específica de la tarea y comparten resultados.
• Crea un programa que utilice algún mecanismo de sincronización distribuida (por ejemplo, semáforos distribuidos) para garantizar el acceso seguro y sincronizado a un recurso compartido.
• Modifica uno de los ejercicios anteriores para incorporar algún mecanismo de tolerancia a fallos. Puedes simular fallos y observar cómo el sistema responde.
• Desarrolla un programa que demuestre la escalabilidad en un entorno distribuido. A medida que se agregan más nodos, la capacidad del sistema para manejar la carga de trabajo debe aumentar.
• Crea un sistema distribuido que distribuya tareas entre múltiples nodos para procesar en paralelo. Asegúrate de que los resultados de las tareas paralelas se recojan y combinen adecuadamente.

Estos ejercicios están diseñados para proporcionar práctica en conceptos clave de programación distribuida y concurrente.

Si eres nuevo en la programación distribuida, es posible que encuentres ciertos desafíos al principio, pero estos ejercicios están diseñados para ser accesibles y educativos. Se recomienda abordarlos en orden y, si es necesario, buscar recursos adicionales o consultar la documentación relacionada con las tecnologías que se este utilizando.

La entrada Ejercicios | programación distribudia se publicó primero en Frexus.

Ejercicios

• Contador Concurrente
  • Escribe un programa que utilice dos hilos para incrementar y decrementar un contador compartido. Asegúrate de manejar adecuadamente la exclusión mutua para evitar condiciones de carrera.
• Imprimir en Orden
  • Crea tres hilos que impriman “Uno”, “Dos” y “Tres”, respectivamente, en orden. Asegúrate de que cada hilo espere al hilo anterior antes de imprimir su número.
• Productor-Consumidor
  • Implementa un problema de productor-consumidor utilizando dos hilos productores y dos hilos consumidores. Utiliza una cola compartida para la comunicación entre productores y consumidores.

Codificación

Solución 1: Contador Concurrente en Python

import threading
import time

contador = 0
mutex = threading.Lock()

def incrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador += 1

def decrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador -= 1

# Crear hilos
hilo_incrementar = threading.Thread(target=incrementar)
hilo_decrementar = threading.Thread(target=decrementar)

# Iniciar hilos
hilo_incrementar.start()
hilo_decrementar.start()

# Esperar a que ambos hilos terminen
hilo_incrementar.join()
hilo_decrementar.join()

print("Valor final del contador:", contador)

Explicación

• Se utiliza un contador compartido (contador) que dos hilos (incrementar y decrementar) modifican simultáneamente.
• Se utiliza un cerrojo (mutex) para garantizar la exclusión mutua y evitar condiciones de carrera.
• Cada hilo realiza un millón de incrementos o decrementos dentro de la sección crítica (dentro del with mutex).
• Al final, se imprime el valor final del contador.

Solución 2: Imprimir en Orden en Python

import threading

def imprimir_uno():
    print("Uno")

def imprimir_dos():
    print("Dos")

def imprimir_tres():
    print("Tres")

# Crear hilos
hilo_uno = threading.Thread(target=imprimir_uno)
hilo_dos = threading.Thread(target=imprimir_dos)
hilo_tres = threading.Thread(target=imprimir_tres)

# Iniciar hilos en orden
hilo_uno.start()
hilo_uno.join()

hilo_dos.start()
hilo_dos.join()

hilo_tres.start()
hilo_tres.join()

Explicación

• Se crean tres funciones (imprimir_uno, imprimir_dos, imprimir_tres) que imprimen diferentes mensajes.
• Se crean tres hilos (hilo_uno, hilo_dos, hilo_tres) asociados a cada función.
• Los hilos se inician y se espera a que cada uno termine antes de iniciar el siguiente, garantizando que los mensajes se impriman en orden.

Solución 3: Problema de Productor-Consumidor en Python

import threading
import queue
import time
import random

cola = queue.Queue(maxsize=5)

def productor():
    for i in range(5):
        item = f"Elemento-{i}"
        cola.put(item)
        print(f"Productor produce: {item}")
        time.sleep(random.uniform(0.1, 0.5))

def consumidor():
    while True:
        item = cola.get()
        print(f"Consumidor consume: {item}")
        time.sleep(random.uniform(0.2, 0.7))

# Crear hilos
hilo_productor_1 = threading.Thread(target=productor)
hilo_productor_2 = threading.Thread(target=productor)
hilo_consumidor_1 = threading.Thread(target=consumidor)
hilo_consumidor_2 = threading.Thread(target=consumidor)

# Iniciar hilos
hilo_productor_1.start()
hilo_productor_2.start()
hilo_consumidor_1.start()
hilo_consumidor_2.start()

Explicación

• Se utiliza una cola (cola) para la comunicación entre productores y consumidores.
• Hay dos thread productores (hilo_productor_1 y hilo_productor_2) y dos thread consumidores (hilo_consumidor_1 y hilo_consumidor_2).
• Los productores ponen elementos en la cola, mientras que los consumidores los sacan y los imprimen.
• El programa sigue ejecutándose indefinidamente, y los thread se pueden interrumpir manualmente.

La entrada Hilos se publicó primero en Frexus.

A continuación se describe seis ejercicios sencillos que abordan los temas de introducción a la programación concurrente, conceptos de programación concurrente, arquitecturas paralelas y distribuidas, así como algoritmos paralelos y distribuidos.

• Diseña un programa en el que dos hilos impriman mensajes alternativamente en la consola. Utiliza la biblioteca threading en Python o el equivalente en el lenguaje que prefieras.
• Implementa un programa que simule una carrera entre tres hilos. Cada hilo representa un corredor y avanza en pasos aleatorios. Imprime el progreso de cada corredor en la consola y determina el ganador cuando uno de ellos llegue a la meta.
• Investiga sobre arquitecturas paralelas y distribuidas. Diseña un pequeño esquema que ilustre las diferencias clave entre ambas arquitecturas. Puedes utilizar diagramas simples para representar los componentes y la comunicación.
• Crea un algoritmo paralelo simple para la suma de elementos en una lista. Divide la lista en subconjuntos y realiza la suma paralelamente en varios hilos. Asegúrate de gestionar adecuadamente la sincronización.
• Diseña un algoritmo distribuido básico para la coordinación entre nodos en una red. Puedes utilizar un modelo simple de mensajes para que los nodos se comuniquen y tomen decisiones colectivas.
• Modifica un programa existente para hacerlo más eficiente utilizando programación concurrente. Por ejemplo, si tienes un programa que procesa una lista de archivos, divide el trabajo entre varios hilos para mejorar el rendimiento.

La entrada Programación Concurrente se publicó primero en Frexus.

El despliegue tridimensional es fundamental en áreas como la graficación por computadora, la animación, los videojuegos, la visualización científica, la realidad virtual y aumentada, entre otros campos. Permite la creación de entornos visuales más realistas y detallados al agregar profundidad y volumen a las escenas, lo que resulta en una experiencia más inmersiva para los usuarios. A continuación se muestra una serie de ejercicios.

Ejercicios

1. Dibuja un cubo en un sistema de coordenadas 3D y calcula las coordenadas de sus vértices en el espacio tridimensional.
2. Toma un objeto tridimensional simple, como una pirámide o un cono, y realiza proyecciones en perspectiva y ortogonales para representar cómo se vería desde diferentes ángulos.
3. Explora la estereoscopía creando dos imágenes ligeramente desplazadas de un objeto 3D y luego utiliza un visor estereoscópico (como el View-Master) para ver cómo la percepción de profundidad cambia cuando se combinan las imágenes.
4. Crea un programa simple en un lenguaje de programación 3D (como OpenGL) que muestre un objeto 3D y permite al usuario cambiar su vista tridimensional interactuando con el objeto.
5. Dibuja un escenario 3D que incluya varios objetos y experimenta con diferentes ángulos y posiciones de la cámara para lograr vistas interesantes.
6. Elige un objeto simple en tu entorno, como una caja, y determina las coordenadas 3D de sus vértices. Luego, crea un modelo 3D de ese objeto utilizando software de modelado 3D como Blender o Tinkercad.
7. Toma un objeto tridimensional complejo, como una silla, y experimenta con diferentes técnicas de proyección para representar sus vistas desde arriba, desde un lado y desde una perspectiva en un papel o utilizando software de diseño gráfico.
8. Investiga sobre aplicaciones de realidad virtual y cómo se utilizan las vistas tridimensionales para crear experiencias inmersivas. Describe cómo se aplican estas tecnologías en campos como los videojuegos, la medicina o la simulación.
9. Encuentra una imagen estereoscópica en línea y utilízala con un visor estereoscópico o una aplicación para ver la imagen en 3D. Describe tu experiencia y cómo funciona la estereoscopía.

Estos ejercicios te ayudarán a explorar en profundidad los conceptos de coordenadas tridimensionales, proyecciones y visualización en 3D. Te permitirán adquirir una comprensión más completa de la graficación y el despliegue tridimensional.

La entrada Despliegue tridimensional se publicó primero en Frexus.

Las transformadas geométricas son fundamentales para lograr efectos visuales, como mover objetos, cambiar su tamaño, girarlos, reflejarlos o aplicar efectos de distorsión. A continuación se muestra una serie de ejercicios que permiten comprenderlas

Ejercicios

1. Dibuja un objeto simple, como un triángulo, en un plano cartesiano.
2. Realiza una traslación del objeto a una ubicación diferente y calcula las nuevas coordenadas.
3. Verifica gráficamente si la traslación se realizó correctamente.
4. Utiliza un cuadrado como objeto de prueba en el plano cartesiano.
5. Realiza una rotación del cuadrado en torno al origen y calcula las nuevas coordenadas.
6. Experimenta con diferentes ángulos de rotación.
7. Dibuja un polígono simple con coordenadas conocidas.
8. Aplica un cambio de escala al polígono y calcula las nuevas coordenadas.
9. Compara el tamaño del polígono original con el escalado.
10. Tomando un triángulo, trabaja con coordenadas homogéneas para realizar transformaciones.
11. Convierte las coordenadas entre el sistema de coordenadas homogéneas y el sistema estándar.
12. Combina varias transformaciones, como traslación seguida de rotación, en un solo objeto.
13. Calcula las coordenadas resultantes después de aplicar las transformaciones compuestas.
14. Utiliza un polígono irregular y un área de recorte rectangular.
15. Aplica el algoritmo de recorte para determinar qué partes del polígono quedan visibles dentro del área de recorte.

Estos ejercicios te ayudarán a entender cómo funcionan las transformadas geométricas en la graficación y cómo realizar cálculos prácticos. Puedes utilizar software de dibujo o programación gráfica para aplicar estas transformaciones y verificar los resultados.

La entrada Transformadas geométricas y bidimensional se publicó primero en Frexus.

Los primitivos de salida son componentes fundamentales en la creación de imágenes y gráficos en una pantalla o en un dispositivo de salida, como una impresora. A continuación se lista una serie de ejercicios propuestos para desarrollar la habilidad de la programación gráfica.

1. Escribe un programa en un lenguaje de programación (por ejemplo, Python o C++) que abra una ventana gráfica y muestre una imagen simple.
2. Crea una aplicación que dibuje formas geométricas básicas, como círculos, rectángulos y líneas, en una ventana gráfica.
3. Desarrolla un programa que permita al usuario dibujar a mano alzada en una ventana gráfica y guardar la imagen resultante.
4. Escribe un programa que muestre un sistema de coordenadas y permita al usuario hacer clic en un punto para obtener sus coordenadas.
5. Crea una aplicación que realice transformaciones de coordenadas, como traslación, rotación o cambio de escala, en objetos gráficos.
6. Desarrolla un programa que permita al usuario introducir coordenadas y muestre los puntos correspondientes en un gráfico.
7. Programa una aplicación que permita al usuario dibujar puntos en un lienzo y luego calcular la distancia entre dos de esos puntos.
8. Desarrolla un generador de gráficos que coloque puntos en un plano en función de ecuaciones matemáticas.
9. Crea un programa que genere patrones de puntos aleatorios y los presente en una ventana gráfica.
10. Escribe un programa que permita al usuario dibujar líneas entre dos puntos seleccionados en una ventana gráfica.
11. Crea una aplicación que encuentre la intersección entre dos líneas en un plano.
12. Desarrolla un programa que trace líneas de diferentes colores y grosores en una ventana gráfica.
13. Programa una aplicación que permita al usuario dibujar elipses, hipérbolas y parábolas en un sistema de coordenadas.
14. Desarrolla un generador de curvas cónicas que pueda ajustar parámetros como el foco y la excentricidad.
15. Crea un programa que realice una animación de una elipse cambiando su tamaño y forma con el tiempo.
16. Escribe un programa que permita al usuario rellenar áreas de un dibujo con diferentes colores.
17. Crea una aplicación que dibuje caracteres y letras en una ventana gráfica para formar palabras o frases.
18. Desarrolla un programa que aplique efectos de sombreado y texturas a objetos gráficos.

No se debe olvidar que un primitivo de salida se refiere a una operación fundamental o una función básica utilizada en gráficos por computadora y programación gráfica para generar elementos gráficos simples, como puntos, líneas, círculos, rectángulos, y otros objetos básicos. Estos primitivos se utilizan para representar gráficos de nivel inferior y se combinan para crear representaciones gráficas más complejas.

Estos ejercicios pueden adaptarse a tu nivel de conocimiento y al entorno de desarrollo que estés utilizando en tu curso de Graficación. Te ayudarán a aplicar los conceptos aprendidos y mejorar tus habilidades en la generación y manipulación de gráficos por computadora.

La entrada Primitivos de salida se publicó primero en Frexus.

A continuación se lista una serie de ejercicios para realizar mediante el uso de comandos en la terminal de windows

1. Muestra tu dirección IP actual en la red.
2. Muestra una lista de las conexiones de red activas en tu computadora.
3. Pinguea la dirección IP de un sitio web (por ejemplo, “ping www.frexus.com“) y verifica la latencia.
4. Muestra la tabla de enrutamiento de tu computadora.
5. Configura una dirección IP estática en tu adaptador de red Ethernet.
6. Conéctate a una red Wi-Fi específica utilizando el comando netsh.
7. Muestra la información detallada de tu adaptador de red Ethernet.
8. Borra la caché de resolución DNS local.
9. Muestra la configuración de firewall actual en tu computadora.
10. Habilita el servidor Telnet en tu computadora y conéctate desde otra máquina.
11. Cambia el nombre de tu computadora en la red local.
12. Muestra una lista de todos los perfiles de red guardados en tu computadora.

Estos ejercicios te permitirán explorar y practicar comandos relacionados con la red en Windows. Asegúrate de utilizar estos comandos con cuidado, especialmente los que involucran cambios en la configuración de red.

La entrada Ejercicios con comandos en la terminal de windows se publicó primero en Frexus.

A continuación se listan doce sencillos ejercicios donde se hace uso de los comandos más usados de windows en su terminal.

1. Muestra el contenido de la carpeta actual.
2. Cambia el directorio de trabajo a la carpeta “Documentos”.
3. Crea una nueva carpeta llamada “Proyectos” en el directorio actual.
4. Copia un archivo de tu elección a la carpeta “Proyectos”.
5. Renombra ese archivo a “informe_v1.docx”.
6. Muestra una lista de las unidades de disco disponibles en tu computadora.
7. Crea un archivo de texto llamado “notas.txt” con el Bloc de notas y guárdalo en la carpeta “Proyectos”.
8. Muestra el contenido del archivo “notas.txt” en la terminal.
9. Borra el archivo “notas.txt”.
10. Muestra información detallada de los archivos y carpetas en la carpeta “Descargas”.
11. Abre el Bloc de notas desde la terminal.
12. Apaga tu computadora utilizando el comando “shutdown”.

Recuerda ajustar los nombres de las carpetas y archivos según tu estructura de directorios y asegurarte de entender el impacto de estos comandos antes de ejecutarlos. ¡Diviértete explorando la terminal de Windows!

La entrada Ejercicios de comandos básicos de windows se publicó primero en Frexus.

• Escribe una instrucción ensambladora para cargar el valor 42 en el registro AX.
• Utiliza una instrucción para mover el contenido del registro BX al registro CX.
• Transfiere el valor de la memoria ubicada en la dirección 0x1000 al registro SI.
• Mueve el contenido del registro DI a la posición de memoria 0x2000.
• Suma los contenidos de los registros AX y BX y almacena el resultado en CX.
• Resta el valor de DX al valor de AX y almacena el resultado en BX.
• Realiza una operación AND entre los registros AX y CX, y almacena el resultado en DX.
• Utiliza una instrucción OR para combinar los contenidos de BX y DX, almacenando el resultado en AX.
• Realiza un corrimiento a la izquierda (shift left) en el registro AX y almacena el resultado en BX.
• Realiza una rotación a la derecha (rotate right) en el registro CX y almacena el resultado en DX.

La entrada Ejercicios en ensamblador se publicó primero en Frexus.