Pablo Alejandro Costesich: Conway's Game of Life

Programé un juego de la vida. Está en Python, el algoritmo es horrible y salió en menos de una hora (el bugfixing tomó un poco más). Necesita Pyglet, porque fue un desafío de un amigo para probar ese framework. Me había olvidado de lo gratificante que puede ser competir. :P

EDITADO:

El código, por si algo le pasa en pastebin:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from pyglet.window import Window, mouse, key
from pyglet.app import run, exit
from pyglet.clock import schedule_interval, unschedule
from pyglet.image import load
from pyglet.gl import glColor3f, glRectf, gl

class World(Window):
""" The World! """

def __init__(self, x=20, y=20, speed=1, wrap=False):
super(World, self).__init__(500, 500)
self.speed = speed
self.wrap = wrap
self.x = range(x)
self.y = range(y)
self.x_size = x
self.y_size = y
self.grid = [[0 for v in xrange(x)] for i in xrange(y)]
self.alive_matrix = [[(0, 0) for v in xrange(x)] for i in xrange(y)]
self.__running = False

def start(self):
if self.__running:
unschedule(self.update)
self.__running = False
else:
schedule_interval(self.update, self.speed)
self.__running = True

def set_alive(self, x, y, state):
if self.__running:
raise Exception("The Game is running!")
elif state:
self.grid[y][x] = 1
else:
self.grid[y][x] = 0

def __query_neighbours(self, x, y):
alive = 0
for v, w in [(a, b) for b in xrange(y - 1, y + 2) for a in \
xrange(x - 1, x + 2) if (a, b) != (x, y)]:
if self.wrap:
w %= self.y_size
v %= self.x_size
elif w == self.y_size or v == self.x_size or w < 0 or v < 0:
alive += 1
if self.grid[w][v] == 1:
alive += 1
return alive

def evolve(self):
# Generate Alive Matrix
for x, y in ((a, b) for b in self.y for a in self.x):
alive_count = self.__query_neighbours(x, y)
cell_status = self.grid[y][x]
self.alive_matrix[y][x] = (cell_status, alive_count)

for x, y in ((a, b) for b in self.y for a in self.x):
cell, alive = self.alive_matrix[y][x]
if (cell == 0 and alive == 3) or (cell == 1 and alive in (2, 3)):
self.grid[y][x] = 1
else:
self.grid[y][x] = 0

def update(self, dt):
self.evolve()

def on_key_press(self, k, modifiers):
if key.SPACE == k:
self.start()
elif key.ESCAPE == k:
exit()

def on_mouse_press(self, x, y, button, modifiers):
if button & mouse.LEFT and self.__running == False:
idx_x = int((self.x_size/500.0)*x)
idx_y = int((self.y_size/500.0)*y)
state = self.grid[idx_y][idx_x]
if state:
state = False
else:
state = True
self.set_alive(idx_x, idx_y, state)

def on_draw(self):
self.clear()
for x, y in ((a, b) for b in self.y for a in self.x):
if self.grid[y][x] == 1:
win_x_unit = 500/self.x_size
win_y_unit = 500/self.y_size
glColor3f(1, 1, 1)
x1 = win_x_unit * x
x2 = win_x_unit * (x + 1)
y1 = win_y_unit * y
y2 = win_y_unit * (y + 1)
glRectf(x1, y1, x2, y2)

if __name__ == '__main__':
world = World(15, 15, 1, True)
run()

Francisco Malbrán: Unidad

El por-alguna-razón-siempre-siempre-temido-encuentro con uno mismo plantea una especie de paradoja: encuentro vs soledad.

La soledad en realidad no es tal, en tanto consideremos a este concepto como la ausencia de un "otro" en nuestro ambiente, puesto que el temor que se pone en evidencia señala con un dedo tembloroso la existencia de un otro que no es otro que uno mismo.

Las diversas y reconocidas frases anónimas acerca de este tipo de encuentro convergen en una especie de universalidad que a nadie parece resultarle extraña: "Me llevo mal con la soledad", "Necesito tiempo para estar conmigo", "Intenté convencerme de que no era así, pero no pude", "A veces no me soporto ni yo".

Se pone en evidencia entonces, que la soledad es un concepto parajódico, ambiguo, o bien polimórfico, o bien malentendido: Por una parte, se tenderá a pensar que es la ausencia de cualquier ente (con inclinación a sobreentender a este ente como ser humano: ej. "estaba solo con mi gato"). Por otra parte se le asigna al concepto un caracter de ente en sí mismo: el yo que conversa con nosotros.

Quizás la definición verdadera diga algo como "la ausencia de todo ente que no sea uno mismo". Pero lo gracioso reside en la parte de "uno"...

Será cierto que somos una única cosa?

Pablo Benjamín Arroyo: Curso Multimedia de GIMP

Una de las primeras tareas que se realizan con una computadora es la manipulación y creación de imágenes. Una vez que somos capaces de digitalizar una imagen, mediante una cámara fotográfica digital o escáner, nos encontramos con la necesidad de manipular esa imagen o añadirle algo.

Existen multitud de programas para realizar esa tarea: los hay que vienen con la cámara digital, con el escáner y otros programas que podemos adquirir a un buen precio. Cada uno de ellos tiene unas características, pero GIMP tiene algo que no tiene los otros: gratuidad, que unida a su potencia, lo hacen ideal para ser utilizado por la mayoría de la gente.

Objetivos:

1. Conocer los principales sistemas y modelos que fundamentan los sistemas digitales de creación de gráficos.
2. Capacitar en el uso de la herramienta digital GIMP para la creación y tratamiento de imágenes.
3. Conocer en detalle el entorno de trabajo del programa, así como todas sus herramientas y las opciones de cada una de ellas.
4. Crear o modificar cualquier tipo de imagen, para combinarla en cualquier proyecto de infografía.
5. Tener presentes los conceptos básicos del color, para poder elegir un modo de color u otro a la hora de abordar un proyecto.
6. Mejorar la calidad de presentación de nuestra página web (centro, proyecto, grupo de trabajo, etc. ).

Contenidos

Los contenidos del curso se estructuran en diez unidades y un Taller práctico.

0.- Conociendo GIMP.

1.- Imagen digital.

2.- Las capas.

3.- Los textos.

4.- Máscaras y selecciones.

5.- Canales.

6.- Rutas.

7.- El color.

8.- Filtros.

9.- Script-Fu.

10.- Animación y web.

11.- Taller práctico.

A su vez, cada una de las unidades se compone de los contenidos sobre la temática que tratan, una práctica guiada y unos ejercicios. Los contenidos del curso se presentan en una interfaz HTML para ser leídos en la pantalla del ordenador y en PDF para ser impresos. El archivo de descarga es una archivo .Iso que se carga en una unidad virtual o puede ser quemada directamente en un CD.



PARTE 1
PARTE 2

Link






Bookmark and Share

Pablo Benjamín Arroyo: En el principio....................

A esto lo encontre en la lista de correo de red-handed
En el principio DIOS creó el Bit y el Byte. Y con ellos creó la
palabra.

Y había dos Bytes en la palabra y nada mas existía. Y Dios separó el
Uno del Cero, y vio que era bueno.

Y Dios dijo: que se hagan los Datos; y así pasó.

Y Dios dijo: Dejemos los Datos en sus correspondientes sitios. Y creó
los disquetes, los discos duros, los discos compactos.

Y Dios dijo: que se hagan las Computadoras, así habrá un lugar para
poner los disquetes, los discos duros y los discos compactos. Así Dios
creó a las Computadoras, les llamó hardware.

Pero aun no había software. Entonces Dios creó los programas; grandes
y pequeños…Y les dijo: Creced y multiplicaos y llenad toda la memoria.

Y Dios dijo: crearé el Programador; y el Programador creará nuevos
programas y gobernará las computadoras y los programas y los datos.

Y Dios creó al Programador; y lo puso en el Centro de Datos; y Dios le
enseñó al Programador el Directorio y le dijo: Puedes usar todos los
Volúmenes y Subdirectorios, pero NO USES WINDOWS.

Y Dios dijo: no es bueno que el programador esté solo. Cogió un hueso
del cuerpo del Programador y creó una criatura que miraría al
Programador y admiraría al Programador y amaría las cosas que el
programador hiciese. Y Dios llamó a la criatura: el Usuario.

Y el Programador y el Usuario fueron dejados en el desnudo y simple
DOS y Dios vio que eso era bueno.

Pero Bill era más listo que todas las otras criaturas de Dios. Y Bill
le dijo al Usuario: ¿Te dijo Dios realmente que no ejecutaras todos
los programas?

Y el Usuario respondió: Dios nos dijo que podíamos usar cualquier
programa y cualquier pedazo de datos, pero nos dijo que NO
ejecutásemos Windows o moriríamos.

Y Bill le dijo al Usuario: ¿Cómo puedes hablar de algo que incluso no
has probado? En el momento en que ejecutes Windows serás igual a Dios.
Serás capaz de crear cualquier cosa que quieras con el simple toque
del ratón.

Y el Usuario vio que los frutos del Windows eran más bonitos y fáciles
de usar. Y el Usuario vio que todo conocimiento era inútil ya que
Windows podía reemplazarlo.

Así el Usuario instaló Windows en su Computadora y le dijo al
Programador que era bueno.

Y el Programador inmediatamente empezó a buscar nuevos controladores

y Dios le pregunto: ¿que buscas?

Y el Programador respondió: Estoy buscando nuevos controladores,
porque no puedo encontrarlos en el DOS.

Y Dios dijo: ¿quién te dijo que necesitabas nuevos controladores?
¿acaso ejecutaste Windows?

Y el programador dijo: fue Bill, quien nos lo dijo que lo
ejecutáramos…

Y Dios le dijo a Bill: Por lo que hiciste, serás odiado por todas las
criaturas.Y el Usuario siempre estará descontento contigo. Y siempre
venderás Windows.

Y Dios le dijo al Usuario: por lo que hiciste Windows te decepcionará
y se comerá todos tus recursos; y tendrás que usar malos programas; y
siempre permanecerás bajo la ayuda del Programador.

Y Dios le dijo al Programador: por haber escuchado al Usuario nunca
serás feliz. Todos tus programas tendrán fallas y tendrás que
corregirlos y corregirlos hasta el fin de los tiempos.

Y Dios echó a todos del Centro de Datos y bloqueó la puerta de entrada
con una contraseña encriptada, hasta que nos envió a un Programador-
Salvador llamado: "Richard M. Stallman" y escribió GNU y después nació
el hijo de DIos llamado: "Linus Torvalds", quién escribió Linux y unio
éste kernel junto con todo el software GNU y fue asi como el software
libre nació y se expandió por el mundo hasta que aparecieron los
ortodoxos dibianeros, los seguidores de slack, los bien organizados
Red Hateros y los carismáticos Ubunteros con sus ideas mas
renovadoras, entre otras denominaciones y así Dios nos perdonó.




Bookmark and Share

Francisco Malbrán: Inconsistencias

Que te secuestre una pregunta y te mantenga en cautiverio y te arrebate de la boca y de la carne alguna de tus grandes certezas, aunque sea por un pequeñísimo instante.

Pff...

Terror súbito e inalterable.

Aunque dure unos pocos segundos.

Aunque dure unos insignificantes segundos.

Aún así...

...te la debo

Pablo Benjamín Arroyo: Videotutorales de blender

Les dejo un link a una lista de reproducion de youtube: Miscelanea blender. Son unos videosmanuales explicando blender desde 0, muy util para los que recien empiezan con el programa y quedaron un poco asombrados con la rara interfaz de blender y les dejo una impresion no tan buena del exelente programa de diseño 3d.


(clic en la imagen)




Bookmark and Share

Joaquin Sorianello: Mandando el contenido de un directorio como archivos adjuntos

Hoy necesitaba mandar un archivo dividido en 18 partes de 400kB, debido a las limitaciones del proveedor de correo de un colega cubano. La opción de hacerlo a mano es realmente engorrosa, asi que con la ayuda de la documentación de python me mande este script:

import smtplib
import os
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email import encoders
import getpass
directorio = 'Directorio de donde Sacamos los Archivos'
asunto = 'Aca va el asunto'
destinatarios = ['complete aqui con sus destinatarios',]
sender = 'Aca va Nuestra Direccion'
contenido = 'Texto que queremos que se lea en los mensajes'
host = 'servidor SMTP que vamos a usar'
login = 'nuestro usuario'
#creamos el contenedor
listademails = []
numeroParte = 1
listadoArchivos = os.listdir(directorio)
listadoArchivos.sort()
for archivo in listadoArchivos:
path = os.path.join(directorio, archivo)
msg = MIMEMultipart()
msg['Subject'] = asunto + ' %d de %d' % (numeroParte, len(listadoArchivos)))
numeroParte += 1
msg['From']= sender
msg['To']=', '.join(destinatarios)
#msg.preamble = ''
texto = MIMEText(contenido, 'plain')
msg.attach(texto)
#Adjuntamos el Archivo
fp = open(path, 'rb')
adjunto = MIMEBase('application', 'octet-stream')
adjunto.set_payload(fp.read())
fp.close()
encoders.encode_base64(adjunto)
adjunto.add_header('Content-Disposition', 'attachment', filename = archivo)
msg.attach(adjunto)
listademails.append(msg.as_string())

server = smtplib.SMTP(host)
server.login(login, getpass.getpass())
for mail in listademails:
server.sendmail(sender, destinatarios, mail)
server.quit()
Dejo en el lector las criticas pertinentes a esta 'Belleza'(ironicmode =True) que sorprende por su extrema pythonicidad :P

Pablo Benjamín Arroyo: Instalar Blender 2.5 en ArchLinux

La version 2.5 alpha 0 del programa de diseño 3d Blender a salido en los ultimos dias...tuve la oportunidad de probarlo y la verdad que mejoro mucho su interfaz esta toda renovada (mejorada) para un uso mas ameno, incorporo nuevas herramientas (como el terminal de python) y un infinito etcetera que lo van a descubrir toqueteando ustedes mismos la nueva version de blender...


Vamos a descargar y extraer el programa (para micros x86 32b):

$ wget http://download.blender.org/release/Blender2.50alpha/blender-2.5-alpha0-linux-glibc27-i686.tar.bz2



$ tar jvxf blender-2.5-alpha0-linux-glibc27-i686.tar.bz2



Nos movemos a la carpeta de blender:

$ cd blender-2.5*



Ahora, para poder ejecutarlo, vamos a tener que instalar algunas dependencias

$ sudo pacman -S libsamplerate



Para instalar libsamplerate, luego libjpg:

$ sudo pacman -S libjpg



Ahora a probarlo:

$ ./blender



Si te gusta y queres aprender a usarlo y actualizarte del 2.49 te dejo una guia (actualizada) para blender 2.5:



Blog de Joaclint Istgug


Ahora para instalarlo vamos a tener que seguir los siguientes pasos:

Copiar todo a la carpeta /opt/blender-2.5

$ sudo mkdir /opt/blender-2.5



$ sudo cp -r * /opt/blender-2.5



$ sudo cp -r .blender /opt/blender-2.5



Y listo...solo hay que agregar un icono en el menu o en la barra de gnome y a disfrutar de blender mas comodamente :D







Bookmark and Share

Joaquin Sorianello: Segundas Charlas Tecnicas Trimestrales - CafeLug

Hoy me levante temprano, decidí postergar los estudios de química (esto me saldrá caro a futuro) , y me fui al Centro Cultural San Martín, en Sarmiento y Paraná, a las segundas charlas técnicas trimestrales organizadas por Cafelug.

Las charlas estaban divididas en dos grandes grupos: Desarrollo y Administración.
Elejí arrancar con las charlas de administración:


La evolución del shell. Por Nubis G Bruno

Nos presento a la herramienta con la que él esta laburando ahora, llamada RUSH (RUby SHell??). Segun lo que yo entendí, es un shell interactivo de ruby que permite modelizar un host remoto en un objeto de ruby, con métodos ( como todo objeto...bueno, o casi todos) para realizar las tareas necesarias: copiar archivos, buscar usando expresiones regulares, levantar aplicaciones y daemons, y muchas cosas mas.
La aplicación se conecta, usando ssh, a un http server en la máquina remota, desde se ejecutan nativamente los comandos.
Esto permite tener scripts de administración bastante sencillos de comprender, y de escalar, para ejecutar tareas en múltiples hosts. Esto es muy piola para aplicaciones que estén en la nube, donde los hosts suelen ser dedicados y tenés que estar moviéndote de uno a otro todo el tiempo.
Hasta acá todo muy lindo, pero soy un tipo que en este momento no tiene ganas de aprender Ruby, de lo que surge una pregunta básica: ¿existe algo así para Python?. La respuesta es afirmativa y se llama Fabric, pero no es exactamente lo mismo.
Como propuesta a futuro, esta una implementación de objetos Host para python, integrada en IPython (Interesados en organizar un sprint bienvenidos!!).
Balance de la Charla: Muy Buena
Lo Mejor: Nubis la tiene muy clara, y es, en mi opinión todo un code-rockstar!
Lo Malo: La laptop en un momento no quiso saber mas nada con el proyector y nos quedamos sin ver todos los slides y ejemplos.

La siguiente charla fue:

Como Implementar Cloud Computing con Open Source, sobre
Open Solaris.
Por Gabriel Benselum y Pablo Oddera.


En esta charla presentaron un poco a Open Solaris (Instale uno en una VM con VirtualBox mientras daban las charlas) y a todas las herramientas y aplicaciónes que trae para implementar soluciones de cloud computing. Se armo un pequeño debate sobre discos SSD y sus ventajas y estado actual de desarrollo.
Comentaron todas las formas de implementar VM y sus ventajas entre las que destaco: flexibilidad, sea tanto para moverlas y replicarlas "on the fly", ahorro de espacio y ahorro energetico.

La segunda mitad de la charla fue sobre ZFS, el file system que implementa nativamente open solaris, que tiene varias ventajas: Journaling, snapshots, diferentes tipos de raids "Virtualizados" y muchas cosas piolas (Piolas para ambientes en los que no trabajo, con volumenes de datos bastante altos).

Balance de la Charla: Muy Buena.
Lo Bueno: Conoci un poco mas de open solaris y de su comunidad. El Tema de ZFS me parecio muy interesante
Lo Malo: En algunos momentos la charla se fue por las ramas, y terminaron medio ajustados de tiempo.
-------------------------------------------------------
Despues vino el break y me fui a Guerrin ingerir una pizza al paso

Despues del Almuerzo:

Video Streaming en grandes cantidades por Leito Monk

Esta charla fue muy motivadora, y me dejo bastante "caliente" por asi decirlo.
Leito junto con otro chico (averiguar nombre) contaron como resolvieron la infraestructura para proveer streaming de las charlas para wikimania 2009.
Utilizaron aplicaciones libres, contenedores y codecs libres, para proveer de un streaming http.
Fue muy ingeniosa la infraestructura y desmuestra como el software libre permite, gracias a la buena documentacion y el KISS crear cosas muy grossas con componentes sencillos.
Gastaron algo asi como 40u$s para contratar Amazon Elastic Cloud, que se encargo de balancear la carga, 500u$s para las computadoras de cada sala y las horas de los camarografos.

Fue una lastima que la PyCon 2009 fue casi pegada a Wikimania, y no se pudo adoptar lo mismo para nuestras charlas.


Balance de la Charla: exelente
Lo Bueno: Con el software libre se pueden hacer cosas muy buenas!
Lo Malo: Realmente nada



A pedido del publico: la documentación esta en http://trac.usla.org.ar/proyectos/wikimania-video


El Cierre fue con:


Introducción a Selenium (Un enanito que trabaja por vos) por Leito Monk

Esta charla fue del track de desarrollo y fue una somera introduccion a Selenium, una herramienta para crear test funcionales para aplicaciones web usando java script.
Yo no me dedico directamente al rubro web pero estub buena para conocer un poco por si las moscas.
Balance de la Charla: Buena
Lo Bueno: Me di un pantallazo de lo que es el testeo web.
Lo Malo: La VM que corria la app de Leito no levantaba la conexión de red y se perdio un buen rato hasta que la cosa salio andando.

---------------------------------------------
Balance General: Las Charlas estuvieron buenas, esperaba ver mas caras conocidas, pero a esta altura del Año todos estamos un poco hasta las manos :P.
Cada día aprecio mas el esfuerzo de toda la comunidad del SL para que estemos todos mas y mejor informados