Bueno, ayer estaba demasiado aburrido, y me puse a escribir un pequeño script en python( 3, porsupuesto) que, dada una serie de strings, las imprime con "formato grande" en consola. Por el momento solo soporta letras desde la A la Z (incluida la ñ gracias al excelente soporte de python 3 para unicode a travez de utf-8).

Por ejemplo. si ejecutamos:

$./bigchars.py hola mundo

Obtendremos la siguiente salida:

H H OOO L A
H H O O L A A
H H O O L A A
HHHHH O O L A A
H H O O L AAAAA
H H O O L A A
H H O O L A A
H H OOO LLLLL A A

M M U U N N DD OOO
MM MM U U NN N D D O O
M M M U U N N N D D O O
M M U U N N N D D O O
M M U U N N N D D O O
M M U U N NN D D O O
M M U U N NN D D O O
M M UUUUU N N DD OOO

Aqui se encuentra el código, no se preocupen por los errores que muestra, mientras usen python 3 no habrá problema ;)

Happy Coding!

Bueno, esto es un rapidín. Me puse a compilar el FLTK 1.3 para Windows, para Visual Studio 2008. Es decir, les entreog los binarios (binaries), dll, lib, headers y ejemplos. Espero les sirva tanto como a mí.

AQUI ESTÁ EL LINK.

Happy Coding!

Bueno, ya que hemos estado hablando de propiedades en C#, vale la pena mencionar las propiedades en D, que son un poquito distintas en su sintáxis, pero igual de poderosas (hasta un poco más!!!). Ya sabemos para qué sirven las propiedades (si en duda, clickea aquí), así que me iré directo al grano, cómo usarlas en D:

Tenemos la declaracion de nuevo de nuestra clase punto, con dos atributos tipo double; x y y, y queremos asegurarnos de que nunca se le asignen valores negativos.

public class Punto
{
this(double xVal, double yVal)
{
x = xVal;
y = yVal;
}

/* Setter para _x */
void x(double newVal)
{
if(newVal >= 0.0)
_x = newVal;
else
_x = 0.0;
}

/* Getter para _x */
double x()
{
return _x;
}

/* Setter para _y */
void y(double newVal)
{
if(newVal >= 0.0)
_y = newVal;
else
_y = 0.0;
}

/* Getter para _y */
double y()
{
return _y;
}

private:
double _x;
double _y;
}

Una clara diferencia con C# es que en D las propiedades no son funciones especiales sino como cualquier otra función. En C# queda más explícito que se trata de una prpiedad, pero la nueva sintáxis para ello podría parecer confusa. Además, en D tu eliges el nombre de la variable que se recibe en el setter :P.

Ahora el cliente de la clase puede hacer:

Punto punto = new Punto(1.0, 2.0);

Stdout.formatln("El valor del punto.x = {}, y punto.y = {}", punto.x, punto.y);

Y recibirá a la salida:

El valor del punto.x = 1.00, y punto.y = 2.00

¿Fácil no?.
Happy Coding!

D se está convirtiendo en mi lenguage de programación favorito (tal vez le logre ganar a C++, quien sabe!!!) a pesar de que llevo experimentando con él solo una semana; poco a poco iré hablando de él. vale la pena señalar que es un lenguage de programación similar a C#, C++ y a Java, es un lenguage que compila a código nativo, y tiene recolección de bsaura. Es de nivel más alto que C++, y permite algunas cosas bastante avanzadas,pero aún asi mantiene cierta compatibilidad con C.

D también es multiplataforma (el compilador oficial DMD tiene soporte para windows y linux, y cualqier plataforma que tenga GCC puede usarlo para compilar D). Y les voy a mostrar como instalar en Linux y en Windows para poder empezar a usarlo y probarlo.

Para Windows:

Nos vamos a http://www.dsource.org/projects/tango/wiki/DmdDownloads yuna vez ahi, bajamos el zip para windows.

Creamos una carpeta en C:\ llamada D y ponemos todo el contenido del zip allí. Ahora solo nos falta agregar dicha carpeta para que esté en el PATH de Windows. Para lograrlo, nos vamos a una terminal (bueno, a la linea de comandos, cmd.exe o como le gusten llamar) y hacemos:

set path=\d\bin

Para corroborar que haya funcionado, solo hacemos en consola:

dmd

Y debería imprimirnos el modo de uso de DMD. Listo.


Para Linux:

Bajamos el tar.gz de http://www.dsource.org/projects/tango/wiki/DmdDownloads y descomprimos el archivador en una nueva carpeta llamada d en nuestro directorio home. Luego hacemos:

$cd d
$sudo mkdir /opt/dmd
$sudo mv ./* /opt/dmd/
$export PATH=/opt/dmd/bin:$PATH
$sudo gedit /opt/dmd/bin/dmd.conf

Y cambiamos el contenido del archivo por:

[Environment]

DFLAGS=-I%@P%/../import -L-L%@P%/../lib -version=Tango -defaultlib=tango-base-dmd -debuglib=tango-base-dmd -L-ltango-user-dmd

Y listo.

Hoy no hablaré más por que ya estoy cansado, pero queda pendiente mucha plática sobre D.

Happy Coding!!!

Si han tenido que diseñar software aunque sea un poco trivial, se deben haber dado cuenta de lo necesarios que son los setters y los getters. ¿Cómo para qué? . Bueno, imaginemos que diseñamos la hipotética clase Punto; que representa un punto en un plano cartesiano.

Class Punto
{
public int x;
public int y;
}

Ahora algún cliente que vaya a usar la clase podría hacer algo así:

Punto miPunto;
miPunto.x = 500;
miPunto.y = 0;

Todo simple y sin problemas no?... Bueno ¿Qué pasa si de repente nos damos cuenta que necesitamos asegurarnos que las entradas no sean negativas? Ahí es donde entran los setters y los getters. Ahora rediseñaremos nuestra clase usandolos:

Class Punto
{
private int x;
private int y;

public int getX()
{
return x;
}

public int getY()
{
return y;
}

public void setX(int new)
{
if(new < x =" new;" y =" new;">

Y ahora ya podemos estar seguros que nunca se van a signar valores negativos a nuetras coordenadas : D . Ahora lo malo es que esta notación lleva al cliente a TENER que cambiar su código. Ahora el código del cliente de la clase quedaría así:

Punto miPunto;
miPunto.setX(500);
miPunto.setY(0);

Y no solo eso, sino que la notación es bastante incómoda y poco intuitiva. Qué pasa si por ejemplo queremos incrementar a x ? El cliente tendría que:

miPunto.setX(miPunto.getX() + 1);

¿De verdad se entiende la intención de esa linea claramente?. No mucho!!!.

C# proporciona un truquito muy lindo para manejar este tipo de asuntos, y una alternativa mucho más sana (mentalmente hablando) a los getters y setters; las propiedades.

Las propiedades son un tipo especial de método que C# (bueno también mi querido Python) nos ofrece para hacer más transparente este proceso de getting y setting. Vamos directo al grano, rediseñemos nuestra clase haciendo uso de las Properties.

Class Punto
{
private int _x;
private int _y;

public int x
{
get
{
return this._x;
}
set
{
if(value < _x =" value;" _y =" value;">

Listo. Ahora el cliente no tendría que cambiar su código, y aún así podríamos estar seguros de no asignar valores negativos! No solo eso, sino que en general el uso se vuelve más claro, ahora por ejemplo si queremos incrementar x, solo tenemos que hacer:

miPunto.x++;

Mucho más claro ¿no?. Bueno, gracias por leer, espero les haya sido útil la información.

Happy Coding!

Bueno, primero que nada quiero explicar mi ausentismo para con el blog. Había estado muy muy ocupado con la escuela y con el servicio social. Pero ahora que estamos en alerta con esta del virus de la influencia porcina, (para más información de click aquí) tengo suficiente tiempo para poder postear unas cuantas cosas aquí.

Estoy en mi servicio social ando, junto con mi equipo, realizando un sistema de información para un pequeño proyecto para el Instituto Mexicano del Petróleo, del cuál no puedo dar detalles. La persona con la que trabajamos (Dra. Elizabeth Mar) tiene un montón de información más bien mal organizada en unas hojas de cálculo de Excel (.xls) y tenemos que trabajar con dicha información.... Bueno, hicimos nuestro diseño de la base basados en la información obtenida y la requerida, ahora solo faltaba poder migrar la información almacenada en los xls a nuestra base MySQL. Así fue como decidimos usar C# para el desarrollo de nuestra aplicación (una simple aplicación de escritorio, sin servidor; no necesitamos más), pues el entorno que nos da Microsoft en su Visual Studio nos deja interactuar fácilmente y sin dolor con hojas de Excel.

Tuvimos varias opciones para elegir, (como interfaces COM, o add in para Microsoft Office), pero decidimos mejor acceder a la hoja de Excel como una Base de Datos con drivers OLE. Bueno, sin más ni más les dejo un snipet de código muy similar a lo que estamos usando nosotros.

using System;
using System.Data;
using System.Data.Common;
using System.Data.OleDb;
using System.Collections.Generic;

....
....

/* La coneccion a la hoja y la extraccion de los datos */
OleDbConnection connection = new OleDbConnection
("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" +
filePath + ";Extended Properties=Excel 8.0");

DataSet dataSet;
OleDbDataAdapter command;

try
{
connection.Open();
}
catch(OleDbException ex)
{
Console.WriteLine(ex.Message);
throw new ImporterException("Error al Abrir la conexion con el " +
"XLS");
}

try
{
dataSet = new DataSet();
command = new OleDbDataAdapter(" SELECT * FROM [" + sheetName + "$]",
connection);

command.Fill(dataSet);
connection.Close();
}
catch (System.Exception ex)
{
throw new ImporterException("Error al extraer los datos de la hoja. " +
"Tal vez estan mal los nombres del xls o de la hoja?.");
}
/* Con este foreach navegamos en cada renglón del XLS */
foreach (DataRow row in dataSet.Tables[0].Rows)
{
/* ahora leemos la primera celda de dicho renglón
y lo imprimimos en consola */
Console.WriteLine(Convert.ToString(row));

}

Y ya, jajaja. Si tienen algún problema, coméntenme y trataré de ayudarlos.

Happy Coding!

Hola de nuevo.
Bueno, antes de empezar a programar en PHP, debemos preparar nuestro entorno de programación. Recordemos que PHP es un lenguaje de programación orientado al desarrollo Web, asi que también instalaremos el servidor Apache.

En ubuntu (o cualquier derivado de Debian) es bastante rápido, solo hacemos:

$ sudo apt-get install php5 apache2 libapache2-mod-php5

Y reiniciamos. Ahora en nuestro navegador introducimos como direccion http:\\localhost\ . Solo para probar si se instaló correctamente apache.

Para Windows, también es bastante fácil: primero para instalar apache lo bajamos de aquí http://apache.mirror99.com/httpd/binaries/win32/apache_2.2.11-win32-x86-openssl-0.9.8i.msi . Y lo instalamos.

Luego para instalar PHP, lo bajamos de aquí: http://www.php.net/get/php-5.2.9-1-win32-installer.msi/from/a/mirror (escogiendo cualquier mirror) y lo instalamos.

Después reiniciamos.

¡Listo! ya tenemos nuestro entorno preparado.

Happy Coding!

Aunque he estado un poco ocupado por la escuela (y solo un poquitín ocupado con mi servicio social, pues somos medio flojos), me empecé a aburrir. Y es que no he tenido retos reales en cuanto a programación, ni me han puesto a aprender algo que me interece lo suficiente (en realidad OpenGL no me intereza demasiado, prefiero aprender gráficos 2D). Asi que he decidido ponerme a aprender PHP, pues me hace falta, ya que nunca he desarrollado una aplicación web : (

Bueno, pero empecemos hablando un poco sobre php. PHP es un lenguaje de scripting, es decir es un lenguaje interpretado en el momento de ejecución. Esto nos permite algunas comodidades lindas como las de python: crear variables sin declararlas, y recolección de basura automática.

Próximamente estaré posteando más acerca de mis nuevos conocimientos de PHP.

En Windows, mi ambiente favorito de programación de c++ es Visual Studio, que es realmente útil, intuitivo y productivo.

En Linux, el único IDE que me ha agradado al nivel del VS, es el plugin de c++ de NetBeans, llegándome a gustar aún más en algunas cosas.

Cuando empecé a aprender openGL, lo hice en Windows (por mi maestro de grafición -_- jajaj, el hombre creo que está daltónico : P), pero después de dos días ya me sentía medio incómodo ahí, y decidí preparar mi entorno para programar en linux.

Debido a la facilidad para instalar glut en Debian, creí que al usar NetBeans no tendría ningún problema de configuración, y que el solito se iba a hacer cargo de ligar el programa que estaba haciendo con las bibliotecas apropiadas. Oh boy, my bad. Estaba un poco equivocado.

Empecé a hacer una pequeña aplicación para probar. Plop!, aparecen unos errores del compilador acerca de unas referencias no definidas (undefined references) por cada identificador que uso que se supone está en glut.h ... ¿Qué pasa? Bueno que el ligador (linker) no está siendo informado de la localización de las bibliotecas de openGL, ni de glut.


Después de rascarme el coco como por media hora, logré resolver mis problemas, para ésto:

Primero, damos click derecho sobre nuestro proyecto que esté usando glut, y escogemos "Properties" del menú que se despliega.





















Se abrirá un cuadro de diálogo, y damos click en "Linker". Primero modificaremos "Additional Library Directories", así que damos click en esa opción y escribimos en ella "/usr/lib:/usr/lib/debug/usr/lib" sin comillas de la siguiente manera:


Después damos click en Libraries, y en el cuadro de diálogo que se abre damos click en "Add Library". En la ventana que se abre navegamos hacia /usr/lib y seleccionamos libGLU.a y libglut.a, mas o menos así:

Ya casi está todo, solo no debemos olvidarnos de hacer esto para ambas configuraciones (debug y release). Ahora escribimos una aplicación simple para probar. Compilamos y ejecutamos.


¡Todo un éxito! Espero les sea útil.

Happy coding!

Hace poco (cuestión de días) me he puesto a aprender openGL, pues lo necesito para mi clase de graficación. Fue un golpe bastante duro para mí, nunca había intentado nada relacionado con graficas, ni con dibujo y cuando tuve mis primeras clases me quedé con cara de: O_O.

Pero bueno, ya logré superar la primera barrera de dificultad (acostumbrarme a openGL como una máquina de estados) y estoy empezando (¡solo empezando!) a disfrutarlo.

Soy principalmente usuario de linux, pero también me gusta windows y ya que mi maestro requiere que corramos los programas hecho en su computadora (winxp), pues deseo configurar mi entorno de programación en ambos sistemas operativos. En debian (o la mayoria de las derivaciones de él, incluido ubuntu) es bastante facil instalar glut. Bueno, en realidad no istalaremos glut, sino freeglut que es una implementación libre de glut, pero con compatibilidad binaria.

Solo necesitas hacer:

$ sudo apt-get install freeglut3 freeglut3-dbg freeglut3-dev

Ahora, para windows, primero necesitas descargar este zip. (también lo puedes descargar de aquí) Después lo descomprimimos y colocamos al archivo "glut32.dll" en "C:\Windows\system32". Luego nos vamos a la carpeta del SDK de nuestro ide (por ejemplo yo uso Visual Studio 2008 y dicha carpeta es "/media/c/Program Files/Microsoft SDKs/Windows/v6.0A" y debe ser una similar si usas cualquier Visual Studio) y dentro de la subcarpeta "lib" ponemos el archivo "glut32.lib" (un poco obvio jejeje), y dentro de la subcarpeta "include" ponemos el archivo "glut.h".

Esos son todos los pasos necesarios para tener el glut funcionando en su entorno de programación.

Happy Coding!