Escribir un libro de cocina, es una gran bondad que nos brinda un cocinero, pues nos da la posibilidad de aprender a comer y a su vez de brindar placeres a nuestros amigos o seres queridos; también ofrece la posibilidad del progreso social y económico, pues en él, no sólo están las instrucciones para cocinar sino para trabajar, para vivir. La comida es el combustible del hombre.

No soportaría que las recetas de cocina fueran textos proscritos, patentados y ocultos a la humanidad. Creo que nadie lo toleraría; nos quitarían el derecho a alimentarnos, a disfrutar, a vivir. ¿Acaso puede existir alguien tan perverso como para adjudicarse derechos sobre las papas fritas, el arroz cocido o la sopa de verduras?

Los cocineros solemos ser gente arriesgada, que experimenta y busca por el mundo sabores y posibles combinaciones que nos den el plato perfecto. Un cocinero de verdad, jamás oculta el saber, disfruta tanto compartiendo una receta como preparando el plato mismo. El mejor cocinero no es aquel que más recetas conoce y se las guarda, sino el que es capaz de compartir; es decir, el que tiene la capacidad de enseñar y dar. No es un cocinero aquel que sabe preparar deliciosos manjares pero lo hace sólo para él y no muestra su talento al mundo, a sus amigos o clientes.

Dado esto, algún día me dí cuenta que si compartía mis programas como comparto mis recetas, me convertía en una mala persona, infringía leyes y aparentemente, le vulneraba los derechos de autor a algunas personas o empresas. Pero, ¿cómo es posible que compartir sea algo malo? ¿por qué el dar es ilegal?. Si yo no podía dar mis recetas me sentía miserable y frustrado. No dar mis programas que al fin y al cabo sólo son información, me hacía sentir malvado. Así que decidí hacer algo para cambiar esto.

Comencé a buscar por el mundo como cuando se busca una especia extraña, buscando esa receta o esa fórmula para poder dar y recibir sin convertirme en delincuente. Además creo que si tienes algo bueno y lo das, eres muy bueno y si tienes algo malo y lo das eres muy malo; es decir, que si le doy a alguien un programa de computador que es malo porque me impide compartir y ser libre, lo estoy esclavizando. Si tengo un manjar, lo doy. Si tengo un veneno, lo tiro. Esa es la lógica del cocinero.

Así descubrí que existían programas de computador que no sólo se podían utilizar sino que todos podíamos conocer su receta y compartirla con los demás. En otras palabras, el sueño de un cocinero, algo como no sólo servir el plato sino enseñar a prepararlo.

Quién dijo que fuera fácil

No escogí el software libre y GNU/Linux porque fuera fácil. Lo escogí porque es libre y puedo ser un mejor ser humano si lo uso y mejor aún si lo comparto y difundo. Pero no es de asustarse, pues si lo pude hacer yo que soy cocinero y disfruto entre sartenes, woks y cuchillos ¿por qué no tú que eres ingeniero, matemático, cineasta o arquitecto?

El camino es caminando y sólo es cuestión de seguir. Al principio intenté con lo que pensé que era más sencillo, es decir programas que supuestamente lo hacían todo por mi. Descubrí un sistema operativo llamado SUSE que me parecía muy similar a lo que había trabajado. Lo instalé según las instrucciones que traía en un libro gordo y pude hacer muchas cosas. Sin embargo me dí cuenta que no era absolutamente libre y me sentí decepcionado. Así que decidí abandonarlo y seguir en busca del platillo especial de libertad. Me enteré que lo más cercano a la libertad era un sistema llamado Debian, que estaba soportado por miles de programadores y usuarios libertarios, pero que tenía la fama de ser el sistema operativo de los hackers, los gurús y toda la gente que sólo vive para el oficio de los computadores. Recordé la conversación con un comensal científico que alguna vez me dijo: Si lo hizo un humano como Einstein ¿por qué no lo puedo hacer yo que tengo el mismo cerebro?.

Tuve mucha suerte a elegir Debian como mi distribución de GNU/Linux. Ahora me doy cuenta que no sólo es el sistema operativo más robusto y estable que jamás he tenido sino el más libre, manejable y fácil de usar, aunque llegar a este punto me ha costado cierto trabajo y esfuerzo. Pero recuerdo a Don Quijote cuando dijo: “La libertad, Sancho, es uno de los más preciosos dones que a los hombres dieron los cielos; con ella no pueden igualarse los tesoros que encierra la tierra ni el mar encubre; por la libertad, así como por la honra, se puede y debe aventurar la vida, y, por el contrario, el cautiverio es el mayor mal que puede venir a los hombres”. Así que el esfuerzo que he invertido es un costo mínimo para conseguir ser libre.

Parece dramático, pero ser libre desde el uso de las herramientas, es el primer paso para conseguir la libertad, pues la libertad además de ser contagiosa, se esparce por la vida como la sangre. Y así como soy libre en el uso de software, quise libertarme de mi teléfono celular y lo logré. Quise libertarme de los noticieros de televisión y lo logré. Creo que la bella locura de ser libre, le ha dado un nuevo impulso a mi creatividad.

Para ayudar a contagiar al mundo de los no informáticos, estoy preparando mi libro “El Cocinero que instaló GNU/Debian y tuvo éxito” como una guía para personas no técnicas que quieran empezar a conseguir su libertad desde el uso de ese magnifico sistema operativo y que hasta ahora no se han atrevido por la mitificación de la que se ha encargado la misma comunidad, que por fallas de comunicación cierra las puertas al ciudadano y al usuario final de programas informáticos, que son la base para que la sociedad se libere de las multinacionales del software y la comunicación, quienes distribuyen sus programas y mensajes diseñados para que la gente se embelese con el supuesto uso fácil y cesen cada vez más la capacidad de asombro y el ejercicio de analizar y aprender.

Mi libro es un manual para más que “dummies”, que lleva al lector paso a paso por el proceso de instalación de un sistema GNU/Debian con bastantes referencias y aclaraciones de cada proceso que se dan por sentados en la mayoría de los manuales, pues asume que todos sabemos qué es un “sector de arranque” o una “partición”. Para mi libro todos los lectores son cocineros que no tienen ni la más remota idea de los componentes de su computador y necesitan que un amigo los lleve de la mano por este proceso, la mayor de las veces, tortuoso e incierto.

¿Y qué le falta para sacarlo del horno?

Pues la verdad, no mucho, está casi todo cocido y dorado. Espero la salida de “Etch”, la próxima versión de Debian que está “Congelada” en el momento de escribir esta reseña, (es decir está en la etapa previa a ser lanzado como estable, según el procedimiento de Debian). Otra cosa importante es conseguir el patrocinador o editor que desee publicarla en papel, según las condiciones de la licencia Documento-GPL o Creative Commons. Esto es sumamente importante para que el medio no contradiga el mensaje. Por eso y mucho más:

¡Viva el GNU/Linux!

Programar entradas te ofrece varias ventajas, como distribuir adecuadamente tu contenido cronológicamente, tener tiempo de hacer modificaciones o correcciones, etc. El truco del que hablaremos en esta entrada te permitirá listar las entradas que tienes programadas para el futuro. Pienso que es un buen gancho para mantener atentos a nuestros lectores o ganar nuevos.

Los pasos son sencillos, basta con poner la siguiente porción de código en tu plantilla (preferiblemente en el sidebar):

<?php
$my_query = new WP_Query('post_status=future&order=DESC&showposts=5');
    if ($my_query->have_posts()) {
    while ($my_query->have_posts()) : $my_query->the_post(); ?>
        <li><?php the_title(); ?></li>
    <?php endwhile;
}
?>

Eso es todo. Si lo retocas con un poco de CSS quedará bastante bonito; por ejemplo, yo lo he implementado en mi blog:

Fuente: Schweizer

Esto es un hack bastante simple que he hecho para poder previsualizar las entradas mientras escribo, y lo pongo aquí porque tal vez a alguien le sirva. La idea se me vino a la mente puesto que soy un fanático del CSS, y de resaltar las partes importantes de mis entradas con recuadros, colores e imagenes. Por ejemplo, para las notas uso una clase llamada “nota”, con lo cual se ve así:

Hola esto es una nota de prueba. Y se ve de lujo. Hola esto es una nota de prueba. Y se ve de lujo. Hola esto es una nota de prueba. Y se ve de lujo. Hola esto es una nota de prueba. Y se ve de lujo.

Y esto es un comando
para la consola
y se ve muy chulo

Entonces pensé que sería bueno poder ver cuál sería el resultado visual de la entrada mientras la escribía, sin tener que estar abriendo una nueva pestaña para previsualizarla. Y lo único que tuve que hace fue añadir el contenido de mi CSS al archivo wordpress.css, que se encuentra en wp-includes/js/tinymce. Y listo, verás algo como:

Ten en cuenta que si tu CSS hace referencias a imágenes en ésta manera, por ejemplo: background:url(images/rss_icono.jpg) no-repeat left; debes poner la URL completa de la imagen: background:url(http://tupagina.com/wp-content/themes/tema/images/rss_icono.jpg) no-repeat left;.

Al momento de crear una entrada muy larga, como un tutorial por ejemplo, es posible dividir el post en varias páginas de una manera muy sencilla utilizando las etiquetas <!--nextpage-->. Funciona de manera similar a <!--more-->, pero dividiendo completamente el post. Y usándola podríamos obtener resultados como este:

¿Cómo incluir esta característica en nuestra plantilla?

La mayoría de los themes deberían incluir esta importante característica, pero en algunos casos no es así. Por tanto, si la tuya no la posee, tendrás que incluir la función wp_link_pages dentro del archivo single.php (si tu plantilla utiliza ese archivo para mostrar las entradas) o index.php (si se muestran directamente con ese archivo). Los parámetros que podemos pasarle a wp_link_pages son:

• before (string): Texto que va antes de los links. Por defecto <p>.
• after (string): Texto que va antes de los links. Por defecto </p>.
• next_or_number (string): Indica se deben usar los números (number) para las páginas o las palabras Previous y Next (next).
• nextpagelink (string): Texto del enlace siguiente. Por defecto Next page.
• previouspagelink (string): Texto del enlace anterior. Por defecto Previous.
• pagelink (string): Formato para las páginas con número.  Si pones % en el string, será reemplazado con el número de la página.

Por ejemplo:

<?php
wp_link_pages('before=<div class="estilo">Páginas:&after=</div>&pagelink=page %');
?>

Mostraría algo como:

Páginas: Página 1 Página 2 Página 3 Página 4

Todo dentro de etiquetas <div class=”estilo”>, lo que haría muy fácil el proceso de aplicarle un estilo visual con CSS.

También existe una función llamada link_pages, que hace exactamente lo mismo que wp_link_pages. La diferencia es que link_pages, recibe los parámetros por separado, mientras que wp_link_pages los recibe todos en una cadena. IMPORTANTE: la función link_pages se encuentra en estado deprecated, lo que significa que NO se debe usar; siempre utiliza wp_link_pages.

Hacks en la función wp_link_pages()

Si deseas aplicar algún tipo de comportamiento especial a la función wp_link_pages, puedes hacerlo editando el archivo post-template.php, que se encuentra en wp-includes. Debes estar seguro de lo que haces, porque de lo contrario te puedes llevar un susto

En mi caso, por ejemplo, edite dicha función de tal manera que añadiera las etiquetas <span class=”current”> y </span>, para poder aplicar un estilo visual a la “página actual”.

Lo complicado aquí es que debes tener en cuenta el cambio, cuando hagas una actualización de la versión de WordPress. Por tanto es más seguro escribir un plugin, o algo más elaborado. Está en ti decidir qué hacer: un hack rápido y peligroso, o un plugin demorado pero seguro.

Happy hack!

Nota: este artículo te podría interesar si deseas saber cómo solucionar problemas de seguridad de manera “profesional“.

De pequeño siempre quise ser Ingeniero de Sistemas… ahora, con 19 años ya llevo 6 semestres (de 10 aquí en Colombia), aún cuando no he estudiado por 2 años falta de dinero, ya no se que quiero hacer.

Con algo que llevo de experiencia mezclándome con “ingenieros” me da algo de tristeza ver cómo de cada 20 hay 1 que vale la pena. Los demás son personas que no tienen puta idea de lo que hacen, estudiaron esto no por vocación sino porque piensan que se van a forrar en dinero, y además se creen Dioses que todo lo saben (aún cuando dedican la mayor parte de su tiempo laboral chateando con el MSN, volviéndose maestros en el uso del Facebook, o perdiendo el tiempo de cualquier otra manera).

La verdad es que hace tiempo quería escribir algo sobre esto, pero no lo hacía simplemente porque muy seguramente los lectores asiduos de este humilde blog no tienen nada de mediocres, y los ingenieros (a quienes iría dirigida la entrada) ni siquiera saben lo que es un puto lector de feeds, o me leerían usando IE 6.0 (no saben que existen “otros”) que a veces no carga bien esta página.

La historia… (aprende a solucionar problemas de seguridad)

Hace una semana entré a la página web del sistema de transportes colombiano Transmilenio, y descubrí que el sistema de búsquedas era vulnerable a ataques XSS y al famoso SQL Injection, por lo cual procedí (después de jugar un par de horas y descubrir ciertos datos interesantes) a avisar del fallo.

La cosa iba así para un XSS:

hola%' or title like '%hola> <script>alert(/POWNED/)</script><a

Y así para un SQL Injection:

hola%' UNION select * from NOMBRE_TABLA where 1=1 or 1 like '%1

Lo cierto es que esto es algo que se puede solucionar fácilmente, haciendo una limpieza a las variables antes de realizar una búsqueda en la base de datos, pero nuestros super ingenieros (que ni siquiera dieron las gracias) encontraron una mejor solución (la más óptima): deshabilitar las búsquedas.

Y aquí es donde no sé si reir o llorar. Poca vergüenza tiene esta gente, y lo peor es que los hay por montones. Muy triste…

También te podría interesar este artículo: Devolver el orgullo al nombre de “programador” para solucionar el déficit de programadores publicado en Punto de partida

Bonus…

• Protegiéndose frente a la inyección SQL
• Protegerse de un ataque SQL Injection
• Detén los ataques de Inyección SQL antes de que ellos te detengan a ti

P.d. esta es una entrada programada escrita el Viernes 1 de Agosto de 2008. Solo para dejar terminar la semana y ver si lo solucionan.

• Deshabilitar servicios innecesarios. Dependiendo del uso que le des a tu sistema, algunos servicios no son necesarios. ¿Usas Linux para el escritorio? Entonces no necesitas servicios como sendmail, httpd, etc. Por ejemplo, Ubuntu viene con los servicios para manipular dispositivos Bluetooth, pero personalmente no utilizo dispositivos de ese tipo; así que si es tu caso, puedes ir al menú Administración, seleccionar Servicios, y deshabilitar todos aquellos que no uses.
• Deshabilitar módulos del kernel innecesarios. Si tu computador solamente se conectar a internet usando una conexión cableada Ethernet, no necesitas tener cargado el módulo Wireless del kernel. Claro, esto ya es un poco más difícil puesto que es necesario recompilar el kernel, seleccionando sólo los módulos que necesitas.
  La mejor manera de saber cuales son los módulos que actualmente están siendo cargados en tu sistema es instalar Bootchart. Este programa genera información acerca de lo que pasa cuando inicia tu sistema, los módulos que se cargan, con gráficos y todo XD.
• Usar un entorno de escritorio liviano en vez de GNOME o KDE. Sobre todo si tenemos máquinas viejas o lentas; Además, en vez de esperar 30 o 60 segundos extra mientras inician GNOME o KDE, ¿porqué no esperar 10 segundos por Enlightenment o XFCE? No solo te ahorrará tiempo al inciar el sistema, sino mientras lo estás usando.
• Usar un sistema de logueo basado en texto en vez de uno gráfico. La mayoría de mis máquinas Linux inician en el run level 3 en vez del run level 5. Esto hará que se detenga en el sistema de logueo basado en texto, donde solo tengo que poner mi usuario y password y ejecutar startx para iniciar mi entorno de escritorio. Los sistemas gráficos de logins son bonitos, pero incrementan el tiempo de carga y producen dolores de cabeza intentando recuperarse en caso de un fallo con las X.
• Usa una distribución ligera. En vez de cargar una pesada Fedora, Ubuntu o openSuse, ¿porqué no intentar Gentoo, Arch o Puppy Linux? El tiempo de inicio es considerablemente menor con éstas.
• Usar un OpenBIOS. Si eres lo suficientemente experto como para actualizar tu firmware, podrías considerar migrar a una BIOS open source. Una de las cosas por las que es recomendable usar un firmware open source es que permite a Linux inicializar el hardware una vez encendido el PC (en vez de que lo haga la BIOS). Aún así, si no te aventuras a hacer tal cosa, podrías considerar configurar tu BIOS para que, por ejemplo, no busque una unidad de disquete que no existe o que bootee directamente del disco duro (en vez de buscar en la unidad de CD primero).
• Evitar el DHCP. Si estás en una red casera o empresa pequeña, las direcciones IPs no suelen dar muchos problemas. Considera entonces poner una IP fija a tu PC. Esto hará que al inciar no sea necesario conectarse al servidor DHCP para obtener una IP. Si haces esto, asegúrate de configurar el archivo /etc/resolve.conf para que seleccione adecuadamente los servidores DNS.
• Si es posible, deshaste de hotplug. Hotplug es el sistema que te permite conectar nuevos dispositivos y usarlos inmediatamente. Si no necesitas esta característica, bórralo. Esto reducirá el tiempo de carga de tu sistema. En muchos sistemas, hotplug consume muchos recuersos al momento de iniciar el sistema. NOTA: udev ha reemplazado a hotplug en su mayoría; pero si usas una distribución antigua te podría resultar muy útil hacerlo.
• Si eres realmente osado, podrías intentar initng. El sistema initng sirve como reemplazo para el sistema sysvinit y promete ser decrementar el tiempo de carga de sistemas basados en UNIX. Si quieres ver a initng en acción, puedes probar el LiveCD Pingwinek.
• Usar un hack en Debian. Si usas Debian, existe un hack muy simple que puedes usar para inciar tus startup scripts en paralelo. Si le echas un vistazo al script /etc/init.d/rc, verás algo como CONCURRENCY=none más o menos en la línea 24. Cambia esto por CONCURRENCY=shell y deberías ver una reducción en el tiempo que tarda el sistema en iniciar.

Un ejercicio en Java que me regala mi amigo Burnhack, y se trata de un juego llamado “Aguanta el balon”, bastante bueno y divertido. Y como no, se ofrece el código fuente para su estudio y disfrute. Nos comenta Burnhack:

Juego: Aguanta el balon
Programado por: Burnhack
Lenguaje: Java

Descripción y Manejo: Pues jugar a este juego es muy simple, el juego comienza cuando haces click en el balón situado en el centro y sin soltar el ratón debes de arrastrarlo evitando el contacto con los otros y los laterales. A medida que avanza el tiempo también sube su velocidad así que el juego se ira complicando.

Como parte de su descripción he nombrado dos clases: Una llamada balon donde controlé las colisiones, y la otra llamada Fútbol y controle el resto de cosas: Movimiento de balones,Velocidad, Los paneles…

Fallos:

• Los balones no llegan a chocar pero es culpa del dibujo de los balones y no me dedique a hacerlos mejor porque bastante me costo hacer esto jajaja aunque sea cutre
• El timer si hay lo descarga que me diga si cree que es correcto porque le agregue un timer y nose si mide del todo bien el tiempo…ya que creo que depende un poco tambien del pc, de todas formas nose hacerlo mejor.
• La interfaz es la misma cutrecilla…donde se podia poner una barra de desplazamiento para que simule el aumento de la velocidad de los balones y un boton de reinicio ..pero soy muy vago y si funciona asi..pues creo que no hace falta mucho mas.

Y a favor del juego…que te picas muy facilmente y pa echar un rato esta bien.

Descargar código fuente y ejecutables

Gracias por la colaboración, Burnhack!

Siguiendo con nuestro tema de conexiones a bases de datos desde Java… Cuando estamos trabajando con bases de datos y aplicaciones que usen Swing, la manera más elegante de presentar los datos a un usuario es usando tablas usando la clase JTable.

Lo que haremos será básicamente crear una clase que herede de la clase AbstractTableModel:

Esta clase abstracta provee la implementación por defecto de la mayoría de los métodos en la interfaz TableModel. Para crear un TableModel como subclase de AbstractTableModel necesitarás implementar únicamente los sigientes tres métodos:

  public int getRowCount();  public int getColumnCount();public Object getValueAt(int row, int column);

Dicha clase administrará el contenido de nuestra tabla. Ten en cuenta que vamos a trabajar con la base de datos que hicimos aquí. Veamos entonces el código:

import java.sql.*;
import java.util.*;
import javax.swing.table.*;
// Las filas y columnas del objeto ResultSet se cuentan desde 1 y las filas
// y columnas del objeto JTable se cuentan desde 0. Al procesar filas
// o columnas del objeto ResultSet para usarlas en un objeto JTable, es
// necesario sumar 1 al número de fila o columnas para manipular la
// columna apropiada del objeto ResultSet (es decir, la columna 0 del objeto JTable
// es la columna 1 del objeto ResultSet y la fila 0 del objeto JTable es la fila 1 del objeto ResultSet).
public class ModeloTablaResultados extends AbstractTableModel {
    private Connection conexion;
    private Statement instruccion;
    private ResultSet conjuntoResultados;
    private ResultSetMetaData metaDatos;
    private int numeroDeFilas;
    // mantener el registro del estado de la conexión a la base de datos
    private boolean conectadoALaBaseDeDatos = false;
    // inicializar conjuntoResultados y obtener su objeto de meta datos;
    // determinar el número de filas
    public ModeloTablaResultados( String controlador, String url,
            String consulta ) throws SQLException, ClassNotFoundException {
        // cargar clase de controlador de base de datos
        Class.forName( controlador );
        // conectarse a la base de datos
        conexion = DriverManager.getConnection( url );
        // crear objeto Statement para consultar la base de datos
        instruccion = conexion.createStatement(
                ResultSet.TYPE_SCROLL_INSENSITIVE,
                ResultSet.CONCUR_READ_ONLY );
        // actualizar estado de conexión a la base de datos
        conectadoALaBaseDeDatos = true;
        // establecer consulta y ejecutarla
        establecerConsulta( consulta );
    }
    // obtener la clase que representa al tipo de columna
    public Class getColumnClass( int columna ) throws IllegalStateException {
        // asegurar que la conexión a la base de datos esté disponible
        if ( !conectadoALaBaseDeDatos )
            throw new IllegalStateException( "No hay conexion a la base de datos" );
        // determinar la clase de Java de columna
        try {
            String nombreClase = metaDatos.getColumnClassName( columna + 1 );
            // devolver objeto Class que representa a nombreClase
            return Class.forName( nombreClase );
        }
        // atrapar excepciones SQLException y ClassNotFoundException
        catch ( Exception excepcion ) {
            excepcion.printStackTrace();
        }
        // si ocurren problemas arriba, suponer que es tipo Object
        return Object.class;
    }
    // obtener el número de columnas en el objeto ResultSet
    public int getColumnCount() throws IllegalStateException {
        // asegurar que la conexión a la base de datos esté disponible
        if ( !conectadoALaBaseDeDatos )
            throw new IllegalStateException( "No hay conexion a la base de datos" );
        // determinar el número de columnas
        try {
            return metaDatos.getColumnCount();
        }
        // atrapar excepciones SQLException e imprimir mensaje de error
        catch ( SQLException excepcionSQL ) {
            excepcionSQL.printStackTrace();
        }
        // si ocurren problemas arriba, devolver 0 para el número de columnas
        return 0;
    }
    // obtener el nombre de una columna específica en el objeto ResultSet
    public String getColumnName( int columna ) throws IllegalStateException {
        // asegurar que la conexión a la base de datos esté disponible
        if ( !conectadoALaBaseDeDatos )
            throw new IllegalStateException( "No hay conexion a la base de datos" );
        // determinar el nombre de la columna
        try {
            return metaDatos.getColumnName( columna + 1 );
        }
        // atrapar excepciones SQLException e imprimir mensaje de error
        catch ( SQLException excepcionSQL ) {
            excepcionSQL.printStackTrace();
        }
        // si hay problemas, devolver cadena vacía para el nombre de la columna
        return "";
    }
    // devolver el número de filas en el objeto ResultSet
    public int getRowCount() throws IllegalStateException {
        // asegurar que la conexión a la base de datos esté disponible
        if ( !conectadoALaBaseDeDatos )
            throw new IllegalStateException( "No hay conexion a la base de datos" );
        return numeroDeFilas;
    }
    // obtener el valor en una fila y columna específicas
    public Object getValueAt( int fila, int columna ) throws IllegalStateException {
        // asegurar que la conexión a la base de datos esté disponible
        if ( !conectadoALaBaseDeDatos )
            throw new IllegalStateException( "No hay conexion a la base de datos" );
        // obtener un valor en una fila y columna específicas del objeto ResultSet
        try {
            conjuntoResultados.absolute( fila + 1 );
            return conjuntoResultados.getObject( columna + 1 );
        }
        // atrapar excepciones SQLExceptions e imprimir mensaje de error
        catch ( SQLException excepcionSQL ) {
            excepcionSQL.printStackTrace();
        }
        // si hay problemas, devolver objeto cadena vacía
        return "";
    }
    // establecer nueva cadena de consulta para la base de datos
    public void establecerConsulta( String consulta )throws SQLException, IllegalStateException {
        // asegurar que la conexión a la base de datos esté disponible
        if ( !conectadoALaBaseDeDatos )
            throw new IllegalStateException( "No hay conexion a la base de datos" );
        // especificar consulta y ejecutarla
        conjuntoResultados = instruccion.executeQuery( consulta );
        // obtener meta datos para el objeto ResultSet
        metaDatos = conjuntoResultados.getMetaData();
        // determinar el número de filas en el objeto ResultSet
        conjuntoResultados.last();                   // mover a la última fila
        numeroDeFilas = conjuntoResultados.getRow();  // obtener número de fila
        // notificar al objeto JTable que el modelo ha cambiado
        fireTableStructureChanged();
    }
    // cerrar objetos Statement y Connection
    public void desconectarDeLaBaseDeDatos() {
        // cerrar objetos Statement y Connection
        try {
            instruccion.close();
            conexion.close();
        }
        // atrapar excepciones SQLException e imprimir mensaje de error
        catch ( SQLException excepcionSQL ) {
            excepcionSQL.printStackTrace();
        }
        // actualizar estado de conexión a la base de datos
        finally {
            conectadoALaBaseDeDatos = false;
        }
    }
}  // fin de la clase ResultSetTableModel

Cosas por explicar el en código anterior:

• Si tienes dudas respecto a las operaciones hechas con el API de JDBC significa que debes leer esto primero: Ejemplo Programación con JDBC
• public Class getColumnClass(); con este método obtendremos el tipo de dato de la columna (Integer, String, Float, etc).
• public int getColumnCount(); este método devuelve el número de columnas que tendrá la tabla.
• public String getColumnName(int x); devuelve el nombre de la columna X de la tabla.
• public int getRowCount(); este método devuelve el número de filas que tendrá la tabla.
• public Object getValueAt(int f, int c); asigna a la tabla el valor de la celda que se encuentra en la fila f y en la columna c.
• fireTableStructureChanged(); esto le indica al objeto AbstractTableModel que la estructura de la tabla ha cambiado.

Ahora el código del frame que contiene la tabla:

import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
public class MostrarResultadosConsulta extends JFrame {
    // controlador JDBC y URL de la base de datos
    static final String CONTROLADOR_JDBC = "com.mysql.jdbc.Driver";
    static final String URL_BASEDEDATOS = "jdbc:mysql://localhost/ejemplo?user=root&password=";
    // la consulta predeterminada recupera todos los datos de la tabla autores
    static final String CONSULTA_PREDETERMINADA = "SELECT * FROM datos";
    private ModeloTablaResultados modeloTabla;
    private JTextArea areaConsulta;
    // crear objeto ModeloTablaResultados y GUI
    public MostrarResultadosConsulta() {
        super( "Mostrando resultados de la consulta" );
        // crear objeto ModeloTablaResultados y mostrar tabla de la base de datos
        try {
            // crear objeto TableModel para los resultados del a consulta SELECT * FROM autores
            modeloTabla = new ModeloTablaResultados( CONTROLADOR_JDBC, URL_BASEDEDATOS,
                    CONSULTA_PREDETERMINADA );
            JTable tablaResultados = new JTable(modeloTabla);

            getContentPane().setLayout(new BorderLayout());
            getContentPane().add( new JScrollPane(tablaResultados) , BorderLayout.CENTER );
            // establecer tamaño de ventana y mostrarla en pantalla
            setSize( 500, 250 );
            setVisible( true );
        }  // fin de bloque try
        // atrapar la excepción ClassNotFoundException lanzada por el
        // objeto ModeloTablaResultados si no se encuentra el controlador de la base de datos
        catch ( ClassNotFoundException claseNoEncontrada ) {
            JOptionPane.showMessageDialog( null,
                    "No se encontro el controlador de la base de datos", "No se encontro el controlador",
                    JOptionPane.ERROR_MESSAGE );
            System.exit( 1 );   // terminar la aplicación
        } // fin de bloque catch
        // atrapar la excepción SQLException lanzada por el objeto ModeloTablaResultados
        // si ocurren problemas al establecer la conexión a la base de datos
        // y realizar la consulta en la misma
        catch ( SQLException excepcionSQL ) {
            JOptionPane.showMessageDialog( null, excepcionSQL.getMessage(),
                    "Error en la base de datos", JOptionPane.ERROR_MESSAGE );
            // asegurar que la conexión a la base de datos esté cerrada
            modeloTabla.desconectarDeLaBaseDeDatos();
            System.exit( 1 );   // terminar la aplicación
        }
        // desechar la ventana cuando el usuario salga de la aplicación
        // (esta opción sobrescribe a la opción predeterminada de HIDE_ON_CLOSE)
        setDefaultCloseOperation( DISPOSE_ON_CLOSE );
        // asegurar que la conexión a la base de datos esté cerrada cuando el usuario salga de la aplicación
        addWindowListener(
                new WindowAdapter() {
            // desconectarse de la base de datos y salir cuando se haya cerrado la ventana
            public void windowClosed( WindowEvent evento ) {
                modeloTabla.desconectarDeLaBaseDeDatos();
                System.exit( 0 );
            }
        }
        );
    }  // fin del constructor de MostrarResultadosConsulta
    // ejecutar la aplicación
    public static void main( String args[] ) {
        JFrame.setDefaultLookAndFeelDecorated(true);
        new MostrarResultadosConsulta();
    }
}  // fin de la clase MostrarResultadosConsulta

Puedes ver un ejemplo más completo, llamado TableExample, en el set de demos que proporciona el JDK (puedes descargarlo abajo).

Descargas

• Ejemplos y código fuente

Hoy me dedicaré a citar algunos enlaces interesantes que he recopilado durante algunos días… comenzamos con los nuevos números los podcast que suelo escuchar:

• Con respecto a programación tenemos el podcast número 11 de javaHispano, en donde han hecho una excelente entrevista Francisco Moreno Peyrona.
• Tzinacan nos deleita con un nuevo número de Otro Podcast Sobre Linux
• El segundo número de la segunda temporada de Linpodcast
• El número 179 de uno de los mejores podcast sobre Java: Java Posse
• Por último un especial del Podcast de Linux Hispano, en conjunto con dos de los podcasters de JavaHispano Podcast.

Enlaces interesantes

• Mensajería instantánea sobre Linux, un listado con el mejor softawre disponible en sistemas operativos Gnu/Linux para mensajería instantánea
  
• Los empleados de Google ganan U$S 9.000 al mes
• CodePad – Sencilla aplicación para comprobar códigos de diferentes lenguajes directamente de la Web
• Curso Gratuito de SUN: Introduccion a Glassfish
• Nuevo rezo a san Gnu/Linux
• Simple es mejor: Lo bueno, si breve, dos veces bueno
• 101 formas de saber que vuestro proyecto software está condenado al fracaso
• El proyecto Debian esta muriendo según uno de sus desarrolladores
• Si te gusta Twittear, aquí tienes un listado de clientes Twitter para Linux
• Ubuntu 8.04 RC liberado y Ship It funcionando
• El número 14 de la revista Begins
• Primera Beta de openSuse 11.0

Un meme extraño

La verdad no me gusta mucho eso de los memes, de hecho no he seguido ninguno nunca (pido disculpas a los que me envían memes, y nos los sigo), hasta ahora. Pero he recibido uno bastante… “peculiar”, tanto así que he decidio seguirlo. Se trata de tipear el siguiente comando en la consola de tu sistema operativo (Gnu/Linux, por supuesto, aunque si tienes Mac…):

11 mkdir
14 bunzip2
14 cp
19 ./configure
19 gcc
2 cc
2 dh
2 ll
2 readelf
2 time

El meme lo puede seguir el que desee.

Un saludo!

Este lo he encontrado gracias a ElBarney-D y me ha parecido bastante completo. Es un tutorial en PDF de 1027 páginas y que contiene mucha información que te podría servir si estás comenzando en esto de la programación. Lo único malo que veo es que parece un poco viejo, pero de seguro le sirve a mas de uno.

Descargar

Descargar versión en PDF