Casidiablo

Me mudo de aquí

2007-06-25T16:08:00.000-05:00

Pues eso... aunque en realidad me demoré bastante, tomé al fin la decisión, y ahora me he mudado de hosting, y de blog, ya que pasó lo que tenía que pasar: preferí el Wordpress que el Blogger.

Pues nada, solo darles las gracias ya que si no fuera por ustedes que leen y tal (que las cifras van subiendo), pues no me hubiera animado.

Un saludos!!!

P.d. Los que me seguían por un feed, pues nada, que lo cambiena ahora por este:

http://feeds.feedburner.com/casidiablo
Publicidad: Descarga de juegos gratis

Según Microsoft, Ubuntu es Perfecto.

2007-06-23T19:32:00.000-05:00

Bueno, talvez fui un poco sensasionalista con el título del post, mejor jusguen uds. Leo en http://www.groklaw.net/ que Microsoft estuvo mostrando en Marketplace, un pequeño post sobre Ubuntu con link de descarga y tal, y en donde afirma lo siguiente:

Ubuntu es un sistema operativo desarollado por la comunidad que es perfecto para portátiles, ordenadores de sobremesa y servidores. Lo utilices en la escuela, en casa o en el trabajo, Ubuntu contiene todas las aplicaciones que puedas necesitar, desde procesador de texto y programas de correo electrónico, a servidor Web y herramientas de programación. Ubuntu es y siempre será gratuito. Usted no paga licencias.

Claro, esto ya fue borrado, pero para los que no se las creen pueden echar un vistazo al caché de Google.

Leo en Kriptopolis: Bueno, ya nos imaginamos lo que ha podido ocurrir. Este sitio de Microsoft se nutre, probablemente de forma automatizada, de diversas fuentes. Una de ellas puede ser CNet Download, a donde alguien remitió Ubuntu como un software que funciona en todas las versiones de Windows. De ahí debió tomarlo Microsoft y así surgió el enredo. Falta saber si el error del posteador fue intencionado o no, y cómo ha podido pasar desapercibido durante todo un mes.

Revista USR Linux

2007-06-12T12:26:00.000-05:00

Los chicos de la Revista USR Linux hace un tiempo han decidido liberar los primeros doce números de su excelente revista, bajo la licencia Creative Commons by-nc-sa 2.5 ar. Buen provecho!!!

Desde la página oficial:
http://www.tectimes.com/magazines/LINUX/lnx025/cdonline/menu.htm

Revista USR Linux - Edición 12

2007-06-12T12:22:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Knoppix 3.9 (Sebastian Bassi)
//Laboratorio: Dasher (Daniel Videla)
//Laboratorio: PC-BSD (Marcos Ibañez)
//Comparativa: Desktop corporativo (Ariel Corgatelli)
//Nota de tapa: Suites de oficina (Hector Facundo Arena)
//Soluciones: Trucos (Santiago Vazquez)
//Soluciones: Consultas
//Aplicaciones: Samba Secure Antivirus (Ariel Corgatelli)
//Xwindow: Embelleciendo Linux (Juan Pablo Firrincieli)
//Informe especial: Software libre para artistas (Lila Pagola)
//CD-ROM: En el CD (Ariel Corgatelli)
//Programación: Manejo de arreglos en Bash (Demian Pablo Alonso)
//Seguridad: El proyecto TOR (Arturo Busleiman)
//Servidores: Benchmarking y monitoreo (Agustin Casiva)
//Servidores: Un servidor hogareño (Ariel Corgatelli)
//Entrevista: Usuaria 2005 (Hector Facundo Arena)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 11

2007-06-12T12:21:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Antivir Personal 6.30.00.17
//Laboratorio: KOSmo 1.1 (Ariel Corgatelli)
//Laboratorio: VectorLinux SOHO (Ariel Corgatelli)
//Nota de tapa: Programación visual (Demian Pablo Alonso)
//Soluciones: Consultas
//Soluciones: Trucos (Ariel Corgatelli)
//Distribuciones: Gentoo (Marcos Ibañez)
//Shell: URPMI (Agustin Casiva)
//CD-ROM: Ubuntu 5.04 (Sebastian Bassi)
//Xwindow: KDE 3.4 (Juan Marcelo Rodriguez)
//Desarrollo web: PHP Online (Martin Ramos Monso)
//Servidores: OpenMosix (Marcos Ibañez)
//Servidores: LTSP (Jose Jorge Masdeu)
//Entrevista: Ricardo Suaya (Ariel Corgatelli)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 10

2007-06-12T12:19:00.001-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Informe especial: Creative Commons (Marcos Ibañez)
//Laboratorio: Amarok 1.2 (Ariel Corgatelli)
//Laboratorio: RedHat Enterprise 4 (Ariel Corgatelli)
//Laboratorio: ARKLinux (Ariel Corgatelli)
//Nota de tapa: 64 Bits (Hector Facundo Arena)
//Soluciones: Trucos (Ariel Corgatelli)
//Soluciones: Consultas
//Aplicaciones: Nmap (Ariel Corgatelli)
//Salud: El pingüino doctor (Jorge Rodriguez)
//Shell: Quotas de disco (Hector Facundo Arena)
//Shell: YUM (Agustin Casiva)
//CD-ROM: En el CD (Ariel Corgatelli)
//Programación: Funciones (Demian Pablo Alonso)
//Programación: Introducción a MONO (Agustin Casiva)
//Servidores: Coyote Linux (Agustin Casiva)
//Servidores: Un servidor hogareño (Ariel Corgatelli)
//Entrevista: Solaris para todos
//Opinión: Linux inseguro? (Hector Facundo Arena)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 09

2007-06-12T12:17:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Informe especial: FLISOL 2005
//Laboratorio: Linspire 5.0 (Ariel Corgatelli)
//Laboratorio: Abiword 2.2.5 (Hector Facundo Arena)
//Nota de tapa: GNU/Linux + Windows: Amor imposible? (Hector Facundo Arena y Ariel Corgatelli)
//Soluciones: Trucos (Ariel Corgatelli)
//Soluciones: Consultas
//Aplicaciones: Fotografía digital (Juan Marcelo Rodriguez)
//Shell: Open Mosix (Marcos Ibañez)
//Shell: Slackware Linux (Juan Marcelo Rodriguez)
//CD-ROM: DNA Linux (Sebastian Bassi)
//Programación: Girando con Bash (Demian Pablo Alonso)
//Desarrollo web: PHP Surveyor (Martin Ramos Monso)
//Servidores: El comando select (Agustin Casiva)
//Juegos: Glest (Juan Pablo Firrincieli)
//Entrevista: Alejandro Avendaño

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 08

2007-06-12T12:15:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Mandrake 10.2 Beta 2 (Ariel Corgatelli)
//Laboratorio: Skype 0.94.0.1 Beta (Ariel Corgatelli)
//Informe especial: Gurúes (Agustin Casiva)
//Nota de tapa: Emulación (Juan Marcelo Rodriguez)
//Soluciones: Trucos (Ariel Corgatelli)
//Soluciones: Consultas
//Shell: badRAM (Marcos Ibañez)
//Shell: El comando netstat (Ariel Corgatelli)
//Aplicaciones: Exprimiendo Konqueror (Sebastian Bassi)
//Sistemas operativos: Una experiencia de 64 bits (Sebastian Bassi)
//CD-ROM: En el CD (Ariel Corgatelli)
//Programación: Bash en 4 clases (Demian Pablo Alonso)
//Programación: Gambas (Jonatan Pugliese)
//Desarrollo web: Coppermine (Martin Ramos Monso)
//Servidores: PostgreSQL (Agustin Casiva)
//Opinión: Linux corporativo (Hector Facundo Arena)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 07

2007-06-12T12:14:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Server Optimized Linux 18.00 (Agustin Casiva)
//Laboratorio: Ubuntu (Sebastian Bassi)
//Nota de tapa: Reciclá tu hard (Hector Facundo Arena)
//CD-ROM: SuSE 9.1 Personal
//Soluciones: Trucos (Ariel Corgatelli)
//Soluciones: Consultas
//Shell: Cifrado de documentos con GPG (Sebastian Bassi)
//Shell: Software Suspend (Agustin Casiva)
//Sistemas operativos: FreeBSD (Marcos Ibañez)
//Aplicaciones: SpamAssassin (Ariel Corgatelli)
//Personalización: Mejoras visuales (Juan Pablo Firrincieli)
//Principiantes: Cómo acercarse a Linux? (Hector Facundo Arena)
//Juegos: Cube (Juan Pablo Firrincieli)
//Programación: Gambas (Jonatan Pugliese)
//Kernel: ReiserFS 4 (Guido Lorenzutti)
//Servidores: Cups (Juan Marcelo Rodriguez)
//Opinión: El fin de las desktop (Hector Facundo Arena)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 06

2007-06-12T12:12:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Firestarter 1.0 (Ariel Corgatelli)
//Laboratorio: X.org (Ariel Corgatelli)
//Actualidad: Reproductores multimedia (Ariel Corgatelli)
//Nota de tapa: Optimización (Juan Marcelo Rodriguez)
//CD-ROM: En el CD (Ariel Corgatelli)
//Soluciones: Trucos
//Soluciones: Consultas
//Shell: Comando chmod (Ariel Corgatelli)
//Shell: Aplicación de parches (Guido Lorenzutti)
//Sistemas operativos: FreeBSD (Marcos Ibañez)
//Desarrollo web: phpAdsNew (Martin Ramos Monso)
//Seguridad: Auditorías de seguridad (Marcos Ibañez)
//Programación: Un servidor de chat (Demian Pablo Alonso)
//Servidores: Courier-MTA (Arturo Busleiman)
//Opinión: Convivencia en paz (Hector Facundo Arena)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 05

2007-06-12T12:05:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Eventos: CaFeLUG '04 (Hector Facundo Arena)
//Laboratorio: Mozilla Sunbird (Ariel Corgatelli)
//Laboratorio: TuxPaint (Ariel Corgatelli)
//Laboratorio: NVU 0.50 (Ariel Corgatelli)
//Nota de tapa: Hardware (Juan Marcelo Rodriguez)
//CD-ROM: UTUTO-e
//PyMES: SaluX (Jorge Rodriguez)
//Shell: El comando ifconfig (Hector Facundo Arena)
//Shell: Kernel 2.6 (Guido Lorenzutti)
//Soluciones: Consultas
//Soluciones: Trucos (Ariel Corgatelli)
//Desarrollo web: Nuestro propio blog (Martin Ramos Monso)
//Programación: Una línea de Perl (Demian Pablo Alonso)
//Seguridad: PSAD (Guido Lorenzutti)
//Servidores: PostgreSQL (Agustin Casiva)
//Juegos: Vendetta! (Juan Pablo Firrincieli)
//Entrevista: Marcelo Elías

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 04

2007-06-12T12:04:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Mandrake 10.1 Official (Ariel Corgatelli)
//Laboratorio: Thunderbird (Ariel Corgatelli)
//Laboratorio: Firefox 1.0 (Ariel Corgatelli)
//Comparativa: A bajar archivos! (Juan Pablo Firrincieli)
//Nota de tapa: Nuevas distros (Juan Pablo Firrincieli)
//CD-ROM: En el CD (Ariel Corgatelli)
//PyMES: Panda Antivirus (Ariel Corgatelli)
//Internet: La red BitTorrent (Juan Marcelo Rodriguez)
//Internet: Winmodems (Juan Marcelo Rodriguez)
//Soluciones: Trucos (Ariel Corgatelli)
//Soluciones: Consultas
//Shell: BitchX (Juan Marcelo Rodriguez)
//Programación: Programación de plugins (Sebastian Bassi)
//Desarrollo web: PHPBB (Martin Ramos Monso)
//Servidores: Protección al menor (Arturo Busleiman)
//Juegos: Cedega 4.1 (Juan Pablo Firrincieli)
//Entrevista: Diego Saravia

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 03

2007-06-12T12:00:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: SuSE 9.1 Personal (Hector Facundo Arena)
//Laboratorio: OpenOffice 1.1.3 (Ariel Corgatelli)
//Laboratorio: VLC Media Player (Hector Facundo Arena)
//Laboratorio: PearPC (Juan Pablo Firrincieli)
//Comparativa: Mensajería instantánea
//Nota de tapa: A migrar! (Sebastian Bassi)
//CD-ROM: Knoppix 3.6 (Hector Facundo Arena)
//Soluciones: Consultas
//Soluciones: Trucos (Ariel Corgatelli)
//Hogar: El formato PDF (Hector Facundo Arena)
//PyMES: Galopin (Hector Facundo Arena)
//Shell: Dispositivos en GNU/Linux (Ariel Corgatelli)
//Shell: Procesos (Ariel Corgatelli)
//Shell: Linux & Palm (Jonatan Pugliese)
//Seguridad: Nessus (Guido Lorenzutti)
//Servidores: Courier-MTA (Arturo Busleiman)
//Programación: SET's Editor (Demian Pablo Alonso)
//Juegos: Doom 3 (Juan Pablo Firrincieli)
//Entrevista: Martin Olivera (Hector Facundo Arena)

Descargas PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 02

2007-06-12T11:57:00.000-05:00

Contenido:
//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: Linspire 4.5 (Sebastian Bassi)
//Laboratorio: aMule 2.0 (Ariel Corgatelli)
//Comparativa: A navegar!
//Nota de tapa: Audio & Video (Hector Facundo Arena, Juan Rodriguez y Juan P. Firrincieli)
//CD-ROM: En el CD (Ariel Corgatelli)
//Soluciones: Consultas
//Soluciones: Trucos (Ariel Corgatelli)
//PyMES: Luca (Hector Facundo Arena)
//Internet: ADSL en Linux (Juan Rodriguez)
//Shell: Cómo instalar programas (Ariel Corgatelli)
//Redes: Squid & Netfilter (Arturo Busleiman)
//Programación: Exclusión mutua (Demian Pablo Alonso)
//Seguridad: GRSecurity (Guido Lorenzutti)
//Desarrollo web: OSCommerce (Martin Ramos Monso)
//Servidores: Nuestro propio server (Roberto Alejandro Rey)
//Juegos: Emuladores de consolas
//Entrevista: Daniel Olivera (Hector Facundo Arena)

Descargas en PDF:
[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

Revista USR Linux - Edición 01

2007-06-12T11:53:00.000-05:00

Contenido:

//News: El Heraldo de GNU/Linux y Software Libre
//Laboratorio: A quemar con K3B (Ariel Corgatelli)
//Laboratorio: PlanMaker y TextMaker (Roberto Alejandro Rey)
//Comparativa: GNU/Linux Visual (Juan Pablo Firrincieli)
//Nota de tapa: Y ahora… cuál elegir? (Roberto Alejandro Rey)
//Entrevista: Stallman (Hector Facundo Arena y Demian Pablo Alonso)
//CD-ROM: Mandrake 10 (Roberto Alejandro Rey)
//Soluciones: Consultas
//Internet: ADSL en Linux (Juan Rodriguez)
//PyMES: FacturaLUX (Hector Facundo Arena)
//Hogar: Novell Evolution (Juan Pablo Firrincieli)
//Soluciones: Trucos (Roberto Alejandro Rey)
//Shell: Midnight Commander (Ariel Corgatelli)
//Shell: Todo sobre Bash (Ariel Corgatelli)
//Seguridad: GRSecurity (Guido Lorenzutti)
//Programación: Programación de hilos (Demian Pablo Alonso)
//Programación: AgataReport (Demian Pablo Alonso)
//Desarrollo web: Mambo! (Martin Ramos Monso)
//Servidores: Control de ancho de banda (Arturo Busleiman)
//Juegos: Unreal Tournament 2004 (Juan Pablo Firrincieli)
//Entrevista: IBM ama al Pingüino

Descargas PDF:

[ Descargar en ALTA resolución ][ Descargar en BAJA resolución ]

¿Indeciso?

2007-06-08T15:47:00.000-05:00

A poco te decidiste a probar GNU/Linux, y no sabes que distro escoger entre tantas que te nombran... si es tu caso tal vez quieras hacerte un test en ésta página:

http://www.zegeniestudios.net/ldc/

En donde con un pequeño cuestionario, te sugieren la Distro que más se acomode a tus conocimientos y gustos...

Espero te sirva.

Saludos!!!

Windows Vista Aero VS Ubuntu + Beryl

2007-06-08T14:32:00.000-05:00

Pues, nada complicado saber quien va a ganar.

Instala Windows Vista en 2 Minutos

2007-06-08T14:31:00.000-05:00

sudo grosero >:(

2007-06-06T12:43:00.000-05:00

De seguro la mayoría ya lo conoce, pero para los que no... resulta que el famsos y útil comando sudo tiene un pequeño "huevo de pascua" XD. Es posible configurarlo para que, en caso de errar en el password, no nos pida perdón (Sorry, try again), sino que nos "insulte".

¿cómo se hace? Fácil, editamos el archivo /etc/sudoers, preferiblemente con el comando visudo:

sudo visudo

Colocamos el cursor donde dice Defaults, y agregamos la palabra insults:

Guardamos los cambios (Ctrl+o) y cerramos nano (Ctrl+x). Ahora para borrar los passwords que sudo deja en el caché digitamos:

sudo -K

Ahora para probar, ejecutaremos algún programa con sudo, dandole contraseñas falsas, con lo que nos salen cosas como estas:

Saludos!!!

Actualizados los video tutoriales

2007-06-06T12:17:00.001-05:00

Se han agregado cuatro nuevas entradas en:

Video Tutoriales

Saludos!!!

Tutoriales de Programación de Pics [semi-actualizados]

2007-05-28T14:49:00.000-05:00

Algunos tutoriales de Programación de Pics...

Espero les sirva!!!

Ordenamiento de arreglos con la clase Arrays

2007-05-28T14:30:00.000-05:00

Pues bien, esta vez vamos a tratar uno de los temas típicos, en lo que a la programación se refiere, y me refiero al ordenamiento de arreglos. Esto no solo es un paso más en el desarrollo de la lógica, cuando estamos aprendiendo, sino una herramienta muy útil en el campo de la programación.

Ahora bien, a nosotros nos enseñan los métodos típicos de ordenamiento de arreglos (arrays o vectores, como quieran llamarlo), como lo son el Burbuja, el Quicksort, etc. Pero hay una clase de la API de utlierías de Java (java.util) que nos facilita esto, y es la clase Arrays. Y utilizandola es fácil ordenar un arreglo, con tan solo una instrucción.

La clase Arrays proporciona métodos (funciones) estáticos para manipular arreglos. Estos métodos son de alto nivel, como el sort para ordenar un arreglo, binarySearch para buscar en un arreglo ordenado, equals para comparar arreglos y fill para colocar valores en un arreglo. Y además estos métodos se sobrecargan para los tipos primitivos de arreglos (int, double, etc.) y para los arreglos Object (String, JPanel, Jbutton, etc.).

Para que todo esto quede claro vamos a realizar un fácil ejemplo:

import java.util.*;
public class UsoArrays {

private int numerosEnteros[] = { 1, 2, 3, 4, 5, 6 };

private double numerosDouble[] = { 8.4, 9.3, 0.2, 7.9, 3.4 };

private int llenoEnteros[], copiaNumerosEnteros[];

// inicializar los arreglos

public UsoArrays()

{

llenoEnteros = new int[ 10 ];

copiaNumerosEnteros = new int[ numerosEnteros.length ];

Arrays.fill( llenoEnteros, 7 ); // llenar con 7s

Arrays.sort( numerosDouble ); // ordenar numerosDouble en forma ascendente

// copiar el arreglo numerosEnteros en el arreglo copiaNumerosEnteros

System.arraycopy( numerosEnteros, 0, copiaNumerosEnteros, 0, numerosEnteros.length );

}

// mostrar los valores en cada arreglo

public void imprimirArreglos()

{

System.out.print( "numerosDouble: " );

for ( int cuenta = 0; cuenta <numerosDouble.length; cuenta++)

System.out.print( numerosDouble[ cuenta ] + " " );

System.out.print( "\nnumerosEnteros: " );

for ( int cuenta = 0; cuenta <numerosEnteros.length; cuenta++)

System.out.print( numerosEnteros[ cuenta ] + " " );

System.out.print( "\nllenoEnteros: " );

for ( int cuenta = 0; cuenta <llenoEnteros.length; cuenta++)

System.out.print( llenoEnteros[ cuenta ] + " " );

System.out.print( "\ncopiaNumerosEnteros: " );

for ( int cuenta = 0; cuenta <copiaNumerosEnteros.length; cuenta++)

System.out.print( copiaNumerosEnteros[ cuenta ] + " " );

System.out.println();

} // fin del método imprimirArreglos

// comparar el contenido de los arreglos

public void imprimirIgualdad()

{

boolean b = Arrays.equals( numerosEnteros, copiaNumerosEnteros );

System.out.println( "numerosEnteros " + ( b ? "==" : "!=" ) +

" copiaNumerosEnteros" );

b = Arrays.equals( numerosEnteros, llenoEnteros );

System.out.println( "numerosEnteros " + ( b ? "==" : "!=" ) +

" llenoEnteros" );

}

public int buscarUnEntero(int x)
{
return Arrays.binarySearch(numerosEnteros, x);
}

public static void main( String args[] )

{

UsoArrays usoArrays = new UsoArrays();

usoArrays.imprimirArreglos();

usoArrays.imprimirIgualdad();

int ubicacion = usoArrays.buscarUnEntero( 5 );

System.out.println( ( ubicacion >= 0 ? "Se encontro el 5 en el elemento " +

ubicacion : "No se encontro el 5" ) + " en numerosEnteros" );

ubicacion = usoArrays.buscarUnEntero( 8763 );

System.out.println( ( ubicacion >= 0 ? "Se encontro el 8763 en el elemento " +

ubicacion : "No se encontro el 8763" ) + " en numerosEnteros" );

}

} // fin de la clase UsoArrays

En este sencillo ejemplo, se muestra el uso del método:

Arrays.fill(): que recibe un como argumentos un arreglo, y el valor con el que se va a rellenar el mismo.
Arrays.sort(): que recibe como argumento un arreglo, que será ordenado ascendentemente.
System.arraycopy(): que recibe 5 argumentos. El primer argumento (valoresEnteros) es el arreglo a partir del cual se van a copiar los elementos; el segundo argumento (0) es el índice que especifica el punto de inicio en el rango de elementos que se van a copiar del arreglo; este valor puede ser cualquier índice de arreglo válido. El tercer argumento (copiaNumerosEnteros) especifica el arreglo de destino que almacenará la copia. El cuarto argumento (0) especifica el índice en el arreglo de destino, en donde deberá guardarse el primer elemento copiado. El último argumento especifica el numero de elementos a copiar del arreglo en el primer argumento. En este caso copiaremos todos los elementos en el arreglo.
Arrays.equals(): este método recibe como argumentos dos arreglos que serán comparados, y que retorna un valor boolean como resultado de la comparación. true si son iguales, false en caso contrario... si, ya se que es obvio, pero es que hay gente que... en fin.

Aunque me salí un poco del tema principal (ordenamiento de arreglos), creo que la esencia del mismo queda más que comprendida. Solo agregar que si hasta ahora estás aprendiendo a programar, es mejor que implementes los métodos de ordenamiento a mano, es decir, empleando la lógica y utilizando instrucciones como for, if, else, etc. ya que no tendría gracia utilizar estos métodos sin siquiera tener un poco de experiencia... esta API la implementaron para hacernos las cosas más fáciles, pero no abuses.

Saludos!!!

Acerca de OpenJavaDay - OpenSolarisDay

2007-05-28T12:51:00.000-05:00

No, esto no es un video tutorial XD... es un vídeo acerca de OpenJavaDay y OpenSolarisDay, copio y pego información:

Sun Microsystems y las Comunidades Abiertas de Java y OpenSolaris te invitan al OpenJavaDay - OpenSolarisDay, que se celebrará el próximo dÍa 31 de Mayo, en la Universidad Carlos III de Madrid (campus de Leganés), un encuentro que constituye la décima edición en España de la sesión para desarrolladores.

Concebido como un foro abierto de carácter tecnológico, reunirá a los principales expertos para que compartan las últimas novedades sobre JavaFX, NetBeans, Glassfish, OpenSolaris, OpenJDK, BPEL, OpenESB y SOA entre otras muchas.

El objetivo: hacer realidad la Era de la Participación, promovida por Sun, en el que las Tecnologías Abiertas cobran protagonismo gracias a las Comunidades que se crean en torno a ellas, dando un valor social a los usuarios, y haciendo posible la Web 2.0.

Bonita manera de hacer publicidad, no creen?

Lo prometido es deuda... Sun libera el código fuente de Java

2007-05-26T11:12:00.000-05:00

El proyecto OpenJDK bebe de las fuentes intelectuales de OpenSolaris y tiene como objetivo reunir a su alrededor una comunidad de desarrolladores en código libre que continúen con la plataforma Java.

Tal y como prometió hace ya algún tiempo, Sun Microsystems ha liberado la parte principal del código fuente de Java, fundando para ello el proyecto OpenJDK y colocando online todo el código fuente necesario para compilar una versión funcional del JDK de Java SE (Standard Edition).
La cesión de este código fuente se hace bajo la protección de la licencia GPL versión 2, lo que pese a no sorprender en exceso, por lo menos sí puede provocar nuestra sonrisa al haber sido liberado el código de Solaris bajo un tipo de licencia reconocida como libre pero incompatible con la GPL: la CDDL (Common Development and Distribution License), que es la que habitualmente utiliza Sun y que deriva de la licencia Mozilla en su versión 1.1 .

A partir de este punto, la vida de Java será como la de OpenOffice/StarOffice o OpenSolaris/Solaris: por un lado, la comunidad independiente de programadores desarrollará el estándar y todas las herramientas necesarias para trabajar con él. Esto quiere decir que tanto los entornos de ejecución como el kit básico de programación (JDK) serán desarrollados por esta comunidad.

Por la otra parte, Sun Microsystems utilizará el código fuente de estos proyectos para sus propios productos a los que ofrecerá soporte técnico de pago. Además, la multinacional norteamericana ha prometido que hará lo necesario para que sus herramientas se integren al máximo con el nuevo Java, como por ejemplo el entorno integrado de programación (IDE) NetBeans.

Por el momento, la dirección del proyecto OpenJDK ha sido puesta en manos de un comité interino hasta que sea la propia comunidad formada a su alrededor quien esté lo suficientemente consolidada y cohesionada para elegir por ella misma y de forma democrática un comité director.

La importancia de esta decisión

Java es un lenguaje de programación y plataforma muy importante hoy en día. Su presencia en computadoras de sobremesa y dispositivos móviles (especialmente teléfonos) es notable, existiendo entornos de ejecución para los principales sistemas operativos: Windows, Mac OS X, Linux, Symbian...

Su uso es sobretodo empresarial en las computadoras de sobremesa, aunque también existen numerosas aplicaciones de usuario, y es uno de los reyes indiscutibles de Internet, facilitando la creación de aplicaciones que funcionan online. No obstante, su estrella se ha visto un poco apagada por la irrupción de AJAX.

En el sector de la telefonía móvil son numerosos los programas lúdicos o aplicaciones serias que utilizan Java para ser multiplataforma, ya que hoy en día son pocos los terminales de telefonía que salen de fábrica sin tener instalada la máquina virtual Java.

Con este movimiento, Sun se gana las simpatías del movimiento del software libre (Richard Stallman ya ha apreciado el gesto llevado a cabo por la empresa norteamericana) con toda la cantidad de desarrolladores que ello implica, y que ahora pueden verse tentados por los cantos de sirena de Java y sus posibilidades multiplataforma.

La inclusión de Java en distribuciones GNU/Linux como Debian que hasta ahora no era posible debido a su licencia restrictiva, va a ser ahora factible, lo que implica una mayor penetración de Java en el mercado. Además, ahora ya no nos tendremos que plantear dudas sobre que pasará en el futuro de esta plataforma, pues cualquier cambio va a ser dictado por la comunidad. La continuidad es algo que preocupa al sector empresarial, en el cual -y como he comentado antes- Java tiene un buen mercado, por lo que con este movimiento se tranquiliza a los clientes que puedan estar preocupados por el futuro a medio/largo plazo de la plataforma pese a la solidez demostrada por Sun Microsystems como empresa.

Más información:
OpenJDK: http://openjdk.java.net/
Nota de prensa de Sun anunciando la publicación del código fuente del JDKhttp://www.sun.com/aboutsun/pr/2007-05/sunflash.20070508.3.xml
DiarioRed

Entornos gráficos de bajo en Linux

2007-05-25T07:11:00.000-05:00

Desde http://lpmagazine.org, David Alverez García ha sacado un excelente artículo acerca de los entornos o escritorios para Linux, que no conusmen demasiados recursos, ideal para aquellos que no tienen máquinas muy potentes... desde la misma página leo algo así:

Los entornos gráficos minimalistas son aquellos que consumen muy pocos recursos del sistema, tanto CPU como memoria RAM, permitiendo el uso de Linux con máquinas antiguas para escritorio o incluso trabajar. Este tipo de entornos son con mucha asiduidad usados por desarrolladores, gente experta o con cierto curtimiento en el mundo Linux debido a que ofrecen una gran velocidad de procesamiento, poco consumo de memoria RAM y son simples, lo cual implica menos bugs, son fáciles de usar por norma y la mayoría son muy configurables para cualquier tipo de tarea.

Descargar el articulo en PDF

Imagenes a volar!!!

2007-05-13T17:00:00.000-05:00

Me he pillado en los foros de elhacker.net un Script de JavaScript muy curioso... por ejemplo, en la barra de direcciones del navegador pones el siguiente código:

javascript:R=0; x1=.1; y1=.05; x2=.25; y2=.24; x3=1.6; y3=.24; x4=300; y4=200; x5=300; y5=200; DI=document.images; DIL=DI.length; function A(){for(i=0; i-DIL; i++){DIS=DI[ i ].style; DIS.position='absolute'; DIS.left=Math.sin(R*x1+i*x2+x3)*x4+x5; DIS.top=Math.cos(R*y1+i*y2+y3)*y4+y5}R++}setInterval('A()',5); void(0);

Enter, y listo!!!

En cualquier página sirve, y con los navegadores IE, Firefox, y Opera.

WarZone.elhacker.net, nuevo site de WarGames y retos hacking de elhacker.net

2007-05-10T09:59:00.000-05:00

Pues eso... después de bastante tiempo de desarrollo por fin se ha liberado una zona de Wargames oficial de elhacler.net. Copio y pego:

Esta es un wargame, que contiene una serie de pruebas con "simulaciones" de escenarios con algun vector de ataque.. que van en diversos temas, desde Hack nivel web, hasta criptografia.El funcionamiento de WarZone es el siguiente:Tu empiezas con un rango (new), en el cual se te mostrarán algunas pruebas en varias categorias.Cuando pases cualquier prueba de este rango, pasaras al siguiente, donde tendras acceso a todas las puebas del siguiente rango.Hay 7 rangos, por lo que teoricamente con resolver 7 pruebas terminas warzone.. sinembargo existe tambien la puntuación.Los primeros 5 lugares son mostrados en la pagina de Estadisticas de WarZone.Las puntuaciones de WarZone son dinámicas, es decir, si una persona tiene exactamente las mismas pruebas pasadas que otra, es probable que tengan diferente puntuación, ya que entre otras cosas, WarZone da preferencia a los usuarios que pasaron primero la prueba, y la puntuación estadística que esta persona le da a la prueba.

El post de inaguración: http://foro.elhacker.net/index.php/topic,164444.0.html.

Niblex, para crear tu propia distribución de Linux personalizada

2007-05-07T14:06:00.000-05:00

Menuda distribución de Linux me he pillado. Nimblex es un distro de Linux basado en Slackware, y que puede correr desde un CD o un pendrive USB. ¿y qué con eso? casi todas vienen así ahora.

Lo novedoso de esta distribución es que te permite crear la distro con los paquetes que quieras, antes de haberla descargado... para probar puedes ir a ésta página, en donde puedes seleccionar los programas a instalar. Luego, al darle click en Generate my Nimblex, el programa generará una imagen de disco ISO, lista para descargar.

Está chulo, vale la pena probarlo... claro, si lo que quieres es hacer tu propia distro desde cero, lo mejor es echarle un vistazo al proyecto LFS.

Saludos!!!

Adiaŭ!!!

4 trucos, consejos o tips para el programador

2007-05-05T14:13:00.000-05:00

Aunque es estado un poco offline ultimamente, por cuestiones de trabajo, hay que hacer labor de blogger y postear una que otra vez, que sino el blog se me va al piso. En esta ocasión recomendarles unos consejitos que recopilé en las últimas dos semanas, de dos fuentes recomendadas: Yo, programador y javaHispano. Hay van...

Consejos para programar en Swing

Un listado de consejos y buenas prácticas para desarrollar en Swing. No son patrones, no son trucos, son consejos desde el dolor de haber sufrido durante tiempo fruto de la experiencia y del día a día. No los pases por alto si te vas a meter de cabeza con Swing:

En la aplicación sólo debe haber un único JFrame, correspondiente a la aplicación principal. Todas las ventanas secundarias deben ser JDialog. Todas las ventanas secundarias deben tener una ventana padre, que es a partir de la cual se despliega. Es decir, todos los JDialog secundarios deben tener como padre al JFrame principal. Si desde un JDialog se va a visualizar otro, este segundo debe tener como padre al primero, y así sucesivamente.
Evita en lo posible los JDialog modales, o ten muy en cuenta su jerarquía de padres. El primer JDialog modal no tiene problemas si le pones su padre adecuadamente. Si tienes un JDialog modal visible, no muestres otro JDialog secundario, salvo que también sea modal y sea hijo del anterior. Si pones visibles a la vez dos JDialog modales y no son el uno hijo del otro, tendrás problemas al intentar escribir en ellos o cerrarlos.
Nunca heredes de JFrame o JDialog o JApplet para hacer tus ventanas. Hazlo siempre de un componente que no sea ventana y que no te limite. Si tus ventanas heredan de JPanel, podrás ponerlas siempre que quieras dentro de un JFrame, un JDialog, un JInternalFrame, un JApplet o incluso incrustarlas en otro JPanel. Si tu ventana hereda de JFrame, está condenada a ser un JFrame toda su vida.
Reaprovecha las ventanas, no se las dejes al recolector de basura. Si un botón, al apretarlo, visualiza un JDialog, no hagas un new de JDialog cada vez que pulsas el botón. Es mejor hacer sólo un new la primera vez y guardarselo. En las siguientes veces bastará con hacer setVisible(true) y setVisible(false). Para que el recolector de basura libere una ventana, además de lo habitual, hay como minimo que llamar al método dispose() de dicha ventana -cosa que mucha gente no sabe- , para que el sistema de eventos de teclado y ratón eliminen todas las referencias que tienen a ella. De todas formas, incluso así no tengo muy claro que los JDialog se liberen siempre y, desde luego, en versiones anteriores de java, los JFrame NUNCA se liberaban. La excusa de SUN es que como sólo debía haber un JFrame principal, no tenía sentido liberarlo.
Los layouts para situar componentes no son tan complicados, sólo hay que ponerse a ello. No uses el layout null, ya que tu ventana no será redimensionable y puedes tener problemas si cambia la fuente de letra, si tu programa se ejecuta en otro sistema operativo, se cambia el look & feel, etc.
Una vez que sepas los layouts simples, tenderás a hacer ventanas grandes a base de anidar muchos JPanel que a su vez tienen dentro JPanel que su vez tienen dentro JPanel, todos ellos con un layout simple. Eso hace ventanas muy pesadas y que consumen mucho. Aprende a usar el GridBagLayout para hacer un solo panel con todo. La excepción a esto es que tengas pequeños JPanel reutilizables, como un editor de coordenadas geográficas que pida latitud, norte/sur, longitud, este/oeste, un panel que pida usuario y password, etc.
Todos los eventos de ratón y teclado se ejecutan en el mismo hilo que repinta las ventanas. Si en un actionPerformed(), keyPressed(), … tu código tarda mucho o pretendes que se pinte algo en una ventana, simplemente no lo hará hasta que tu código termine. Si tu código en un actionPerformed() va a tardar mucho o tiene que pintar cosas en la ventana, lanza un hilo aparte para hacer esa tarea y termina el actionPerformed() lo antes posible.

Los diez errores más comunes en el diseño de una base de datos

Un poco off-topic este enlace pero creo que es bastante interesante para la mayoría de los desarolladores que consultan este portal. Louis Davidson es un experto en el diseño de Base de Datos y es autor del libro SQL Server 2005 Database Design and Optimization en el artículo aquí enlazado presenta los diez errores más comunes en el diseño de una BD que el ha detectado a lo largo de su experiencia:

Mala planeación del diseño
Ignorar la normalización
Estándares de nomenclatura deficientes
Falta de documentación
Una sola tabla para guardar todos los valores del dominio
Usar columnas GUID como la única llave de una tabla
No usar las funcionalidades SQL para preservar la integridad de los datos
No usar Stored Procedures para acceder a los datos
Intentar construir objetos genéricos en los stored procedures
Falta de pruebas

En mi experiencia la mayoría de los desarrollos donde he trabajado presentan algunas de estas deficiencias en su base de datos. Creo yo que en muchos de los casos es porque se deja a un programador diseñar la base cuando debe ser haber un DBA involucrado en el proceso. Se que muchos proyectos no pueden pagar el sueldo de un DBA en exclusivo pero creo que al menos debe haber un DBA por organización que supervise el diseño elaborado por los programadores, lo mejore y le de su visto bueno.

Con las bases de datos pasa como con el diseño web, cuando se deja en manos de un programador el resultado puede ser un desastre e imagino que la mayoría de ustedes ha tenido que lidiar con chapuzas como una tabla totalmente desnormalizada (digo a veces está bien desnormarlizar para ganar en desempeño pero hay límites) y que necesita de 5 o más campos para tener una llave compuesta (y dile adios a tu idea de usar un ORM para la capa de datos), o una tabla con 20 campos que se llaman campo1, campo2, .. campoN y que nadie en la organización sabe que diablos es el campo7 o quién era el encargado de actualizarlo pero sin él tu aplicación no funciona, en fin no seguiré descargando mi frustración aquí :P . En mi opinión una forma de evitarle frustraciones a los otros programadores es que, dado que las empresas no van a querer pagar un DBA para auxiliarte en el 70% de los casos,nosotros nos documentemos con artículos como el de Louis para realizar un mejor trabajo que programar no es solo usar Spring o el último patrón de diseño.

Los 12 principios sobre test unitarios

Alberto Savoia ha dejado una entrada en su blog donde nos descubre los secretos del buen hacer con tests unitarios. Está escrito con toques de humor, a modo de manuscrito antiguo y es, sin duda, una amena lectura para la vuelta al tajo (y al debate). Les traduzco los 12 principios con los que concluye su artículo (corregirme si se me ha pasado algún juego de palabras):

Si escribes código, escribe tests.
No seas inflexible siguiendo el dogma del test unitario.
Abraza el karma del test unitario.
Piensa en código y test como un todo.
El test es más importante que la unidad.
El mejor momento para hacer tests es cuando el código está fresco.
Hacer tests no es perder el tiempo.
Un test imperfecto hoy es mejor que un test perfecto mañana.
Un test feo es mejor que ningún test.
A veces, el test justifica los medios.
Sólo los tontos no usan herramientas.
Los buenos tests fallan.

10 problemas de rendimiento de J2EE

Siguiendo con los listados "top" de los últimos días, me entero vía TSS de la lista de los 10 errores de rendimiento más comunes en las aplicaciones J2EE. Coincido con algunos de ellos y otros me dejan perplejo. Traduzco y comentamos :

10. Excesivo Logging
9. Configuración del Serv. de Aplicaciones incorrecta.
8. Uso incorrecto de Java EE
7. Uso innecesario de XML
6. Configuración de Caché incorrecta
5. Uso de memoria excesivo
4. Pobre rendimiento de librerias de terceros
3. Mala implementación de concurrencia
2. Remoting innecesario (remoting es una llamada a un elemento local como si fuera externo).
1. Uso incorrecto de la base de datos.

Sin más, un saludo, y espero que les siga de algo!!!

Programación segura de aplicaciones

2007-04-30T10:19:00.000-05:00

He leído un excelente documento de Kernel Panic Labs, en el que se explica detalladamente

la Seguridad y la Programación segura... un tema de verdad muy importante para los desarrolladores de software. Este es un artículo de imprescindible lectura para aquellos que, como yo, están descubriendo el mundo "real" del desarrollo de software.

Contiene temas como:

Seguridad informática
Desbordamiento de pila
Desbordamiento de memoria dinámica
Inyección SQL
Técnicas para codificación segura
Herramientas para la seguridad de aplicaciones

Descargar !!!

Nuevo subforo de Java en elhacker.net

2007-04-26T19:20:00.000-05:00

Pues eso, se ha puesto un nuevo subforo de java en los foros de elhacker.net. Por fin el-brujo cedió ante tanto acoso XD. En fin, esto me quita un gran peso, ya que: "les pido por favor a mis lectores que envien sus dudas y las canalicen en ese foro", ya que ultimamente estoy bastante ocupado y no tengo tiempo de responder todos los correos con sus dudas.

Pues nada, que lo disfruten... y lean las reglas.

Saludos!!!!

Java Sun y herramientas Java en Ubuntu 7.04

2007-04-19T09:14:00.000-05:00

Pues eso, por fín se han decidido los de Ubuntu. Recordemos que nunca se dignaron en meter un pinche compilador para Java, con esfuerzo y ponían la base del gcj. Pues bien el jdk 6 de Sun y herramientas como Netbeans 5.5, Glassfish y JavaDB estarán disponibles para los usuarios de la nueva versión de Ubuntu, Feisty Fawn (que será publicada hoy, 19 de abril); anunció Mike Shuttleworth, CEO de Canonical.

Estas herramientas estarán disponibles en los repositorios multiverse de Ubuntu para Feisty. Se planea que para el lanzamiento de Java 7, las herramientas Java hayan hecho el salto al repositorio principal de Ubuntu y Java se haya vuelto parte fundamental de dicha distro.

Este anuncio es el resultado de la colaboración entre Sun y Ubuntu para acercar Java al mundo Linux y para incluir Glassfish como servidor de aplicaciones Java en esta popular distribución y hacer frente a la dupla Red Hat + JBoss.

Una gran noticia para los que desarrollamos en Ubuntu, cada vez es más sencillo instalar herramientas Java. Eclipse está disponible en los repositorios Ubuntu desde hace tiempo y se extrañaba lo mismo para NetBeans. Sin duda, Ubuntu se está convirtiendo en la distro GNU/Linux para los desarrolladores Java.

El firefox y sus extensiones

2007-04-17T09:43:00.000-05:00

Nada, aqui probando extensiones para Firefox XD. Algunas de las últimas que han salido, y que me han llamado la atención son estas:

Vimperator... esta extensión es para aquellos amantes del linux. Se trata de una extensión para que transforma a Firefox en un navegador modal al más puro estilo Vim: oculta todos los menús menos las pestañas, añade una pequeña terminal al fondo en la que podremos utilizar el tabulador para autocompletar y tiene mapeadas un montón de combinaciones de Vim, modificadas para la ocasión. Si alguna vez haz usado Vim, tu elección es Firefox y te gusta la navegación con el teclado (por ejemplo, para los portátiles), pruébalo a ver qué te parece. Y si te pierdes, recuerda que puedes ver la ayuda pulsando :help.

Para el Google Reader... en realidad no es exclusivo para Firefox, pero va por la misma onda. Este lo copio y pego de Genbeta...

El juguete o entretenimiento de hoy para los más osados e inquietos tiene a Google Reader y Mac como protagonistas. Se trata de la modificación de la apariencia que en hicksdesign han hecho del lector de noticias de Google. Le han dado un toque, digamos más Mac.

El resultado es realmente bueno y de momento somos varios los editores de Genbeta y Applesfera que lo hemos implementado.

Para hacerlo, nada más sencillo que descargarte el skin y si tienes Firefox, instalar el añadido Stylish. En Opera y otros navegadores también puede hacerse, pero los pasos ya son un poco más complicados.

Nosotros pasamos a explicar el método para Firefox:

Instala el añadido Stylish. Reinicia Firefox.
Descarga el tema y descomprimelo. Escoge el que corresponda a tu navegador.
Visita Google Reader y en la esquina inferior derecha de Firefox dispondrás del icono de Stylish. Haz clic y ve donde pone Escribir Estilo para esta dirección.
Copia y pega el contenido del CSS que te has descargado et voilá.

Better Gmail...

Una extensión para Firefox creada en Lifehacker y que sin duda nos va a poner el Gmail "más bonito". Se trata de una recopilación de scripts para el Greasemonkey, que permiten añadir varias características a Gmail. La instalación es sencilla, y en las propiedades del añadido podemos escoger que scripts queremos usar y cuáles no. Imprescindible.

Video Tutorial Brute force attack sobre servidor ssh

2007-04-17T08:25:00.000-05:00

Una de las responsabilidades de los administradores de sistemas es limitar el acceso a aquellos usuarios con autorización para entrar en el mismo. Con el fin de bloquear el acceso a terceros se crearon las contraseñas. Cada usuario posee un ‘nombre de usuario’ y una contraseña. Cada vez que un usuario quiere acceder al sistema se le piden dichos datos. Si el nombre de usuario y la contraseña coinciden con los almacenados en el servidor le permitimos el acceso, si no, se lo denegamos.

Uno de los problemas de este sistema surge cuando una tercera persona se hace pasar por uno de nuestros usuarios. Siempre y cuando conozca el nombre de usuario y su password se le permitirá el acceso, independientemente de que la persona no sea quien dice ser.

Otro problema es que si el acceso a sido denegado, el usuario puede volver a intentar acceso n numero de veces (normalmente n es infinito). Por lo general, limitar el número de intentos puede bloquearnos el acceso, haciendo del remedio peor que la enfermedad.

Un ataque muy común que se hace uso de dichas ‘vulnerabilidades’ son los ‘ataques basados en diccionarios’ (dictionary-based attack). El ataque consiste en bombardear al servidor con nombres de usuarios y contraseñas aleatorios. Es algo parecido a intentar abrir una caja fuerte introduciendo números al azar. Si alguna vez te has encargado de algún servidor ssh o ftp seguramente los hayas sufrido.

Ya que el número de posibles combinaciones de usuarios y passwords posibles es demasiado alto, en este tipo de ataque normalmente se usan diccionarios. Un diccionario (de passwords y/o usuarios) es un fichero de texto con nombres de usuario y passwords frecuentemente usados. Por ejemplo, en la mayor parte de sistemas nos solemos encontrar un usuario ‘root‘, y, estadísticamente hablando, passwords como ‘1234‘ o ‘qwerty‘ son usadas mas frecuentemente que ‘a\/gW1~3|23‘. Como te podrás imaginar, para diferentes idiomas se usan diferentes diccionarios.

Pero entonces…? SI!, La única manera de que este ataque funcione es que la combinación usuario-password este en tu diccionario, o en otras palabras, una mala gestión de usuarios/passwords.

El motivo por el que este tipo de ataques están tan extendidos es porque con un simple script podemos testear cientos o miles de servidores de forma automática sin necesidad de intervenir en el proceso. Otro motivo es que los ‘chicos malos’ necesitan ordenadores desde los que realizar sus ataques.

En un ataque real conseguir acceso al sistema es solo el primer paso. Una vez dentro se suele instalar como mínimo algún troyano con el cual garantizar el acceso en caso de que se cambie la password. Hay ocasiones en el que el atacante simplemente cambia la password para levantar sospecha y darle a conocer al usuario que su password es débil.

En este video tutorial os muestro un ejemplo práctico de cómo realizar este tipo de ataques y por supuesto como detectar su presencia.

Detalles técnicos

La distro usada para realizar el ataque es Backtrack 2, versión Live.
Para escanear la red y localizar posibles víctimas se uso nmap.
Para el ataque en si utilizamos medusa (~# man medusa).
El diccionario usado pertenece a ‘john the ripper‘ (Incluido por defecto en Backtrack 2).
El servidor de ssh en la víctima es una instalación estándar de OpenSSH.

Ver video tutorial

Pulsa aquí o sobre la imagen para acceder al vídeo tutorial.

Detección y prevención

La mejor forma de detectar este y cualquier tipo de ataque es comprobando los logs y analizando cualquier anomalía. En su día escribí un post llamado ‘Navegando entre los logs’ donde hable de cómo el servidor en el que se encuentra alojado esta web, Fujiyama, estaba en constante estado de alerta.

En ‘Consejos básicos: Mantener un servidor del ssh’ menciono las practicas mas habituales para evitar este tipo de ataques sobre servidores de ssh. En esa época decidí cambiar el puerto de escucha del servidor de ssh y desde entonces no he recibido ningún ataque en los dos últimos meses.

Video Tutoriales

2007-04-17T06:24:00.000-05:00

Video Tutoriales Java

Algunos de los anteriores videotutoriales de Java (básico) fueron tomados del Youtube, gracias al usuario Aphonik.

Video Tutoriales ARP Poisoning

La página web oficial de los Video Tutoriales acerca de ARP Poisoning es http://icaix.com/ y dichos videos están bajo la licencia GPL.

Video Tutoriales Ataque Fuerza Bruta a servidor ssh

Video Tutorial Brute force attack sobre servidor ssh

La página web oficial de los Video Tutoriales acerca de Brute force attack es http://icaix.com/.

Video Tutoriales NetBeans

Video Tutoriales PHP - MySQL

Video Tutoriales JCreator

Vídeo tutoriales SUN CERTIFIED JAVA PROGRAMMER Y SUN CERTIFIED JAVA DEVELOPER

Los anteriores vido tutoriales fueron creados por el Ingeniero Julio Cesar en la ciudad de Mexico, actualmente va en el capitulo 4, la idea es que sirva de apoyo para SUN CERTIFIED JAVA PROGRAMMER Y SUN CERTIFIED JAVA DEVELOPER.

Algunos de los anteriores (NetBeans, PHP, JCreator) vídeos fueron tomados de: www.telnetperu.com, www.netbeans.org y http://certificate.educaleft.com, este es solo un puente de información creado para ti, espero te sirva.

Nuevo numero de la revista Essentia Libre

2007-04-09T13:48:00.000-05:00

Ni tan nuevo, pero hasta ahora me entero XD. Ya vamos en la #6, para descargar seguir alguno de los siguientes links:

Pa' los colombianos...

2007-04-08T14:37:00.000-05:00

Bueno, más exactamente para los Bogotanos... están invitados a un toke que se realizará el 14 de abril de este año, y en el que estarán tocando algunas bandas locales muy buenas, como NxMxA SD, Suburbios, Dekapitados, entre otros... como dice en la imagen, se realizará a las 2:00 p.m. en la Transversal 78H # 43 - 76 (avenida primera de mayo con villavicencio), y tan solo cuesta 4.000 pesos la entrada.

Los esperamos!!!

Ya era hora, se ha liberado Debian Etch!!!

2007-04-08T10:54:00.000-05:00

Por fin han liberado a Debian Etch, la tan esperada nueva versión de esta importante distro de Linux... El correo que me mandan desde las listas pinta más o menos así:

The Debian Project is pleased to announce the official release of Debian GNU/Linux version 4.0, codenamed “etch”, after 21 months of constant development. Debian GNU/Linux is a free operating system which supports a total of eleven processor architectures and includes the KDE, GNOME and Xfce desktop environments. It also features cryptographic software and compatibility with the FHS v2.3 and software developed for version 3.1 of the LSB.

Ahora ya podemos utilizar una nueva versión estable. Puedes ver más información en las noticias de Debian, o buscar un link de descarga aquí.

MyCyberTwin, crea tu "yo" malvado en internet

2007-04-05T17:22:00.000-05:00

Todos hemos visto en la serie “Los Simpsons” cuando Homer se ha buscado, en varias ocasiones, a un sustituto para que temporalmente ocupe su puesto de trabajo. Unas veces era un objeto y otras una persona.

Ya en internet, quizás muchos me veáis online a lo largo del día, y quizás muchos vean en otros que éstos también se pasan la mayor parte de su tiempo en internet. Pero por cuestiones personales y humanas, no nos podemos pasar 24 horas diarias frente a la pantalla de nuestro monitor.

Y eso lo saben bien desde MyCyberTwin, un servicio online que nos permite crear nuestro otro yo en la red. Realmente es un chat bot que establece conversaciones automáticamente con otros usuarios, cuya vida equivale al número de créditos que nos restan cada vez que alguien conversa con nuestro otro yo o enviamos invitaciones por correo electrónico.

Y este chat bot me recuerda a un programa que tenía en el Amiga, incluso seguro que conoceréis el sistema de chat con Dios, donde podemos realizar conversaciones a través de la web. Pues de esto último se trata, de generar nuestro otro yo estableciendo la personalidad que queramos a través del test de 79 preguntas y el entrenamiento que someteremos a nuestro otro yo para que actúe de determinada manera dentro de las conversaciones con otros usuarios.

Las conversaciones se pueden establecer desde nuestra url personal o bien mediante un widget en cualquier perfil de nuestra red social, web propia o donde queramos, de modo que los usuarios que entren en conversaciones con nuestro otro yo estén entretenidos, mientras nosotros, los verdaderos, estamos haciendo otras cosas.

Hmmm, ahora que lo pienso, la de bromas que podemos gastar con este sistema, aunque lo malo es que dejemos de tener amigos…

Vía | Web2null
Enlace | Sitio oficial de Mycybertwin

Jugando en Linux

2007-03-31T14:55:00.000-05:00

Los que usen Knoppix sabran de un juego (aparentemente aburrido) para niños llamado Potato Guy, pero a mi me parece lo mas de divertido XDDDD, si sos de los que no se aguantan un chiste mejor ni veas las imagenes de abajo:

¿Bug en Hotmail?

2007-03-26T10:28:00.000-05:00

Pues al parecer alguien ya ha descubierto un bug en hotmail que permite tener acceso a dichas cuentas, robando las cookies de la victima. Puedes encontrar información acerca de como explotar esta vulnerabilidad aquí:

http://www.hackhispano.com/foro/showthread.php?p=120231

Saludos!!!

Video Tutorial Java: Gestion de excepciones con try catch y throws

2007-03-23T09:56:00.001-05:00

Conoce mejor un paquete: java.util

2007-03-23T09:55:00.001-05:00

Video Tutorial - Conoce mejor un paquete: java.lang

2007-03-23T09:53:00.000-05:00

Video Tutorial Acceso a BBDD en Java utilizando Eclipse

2007-03-23T09:52:00.000-05:00

Video Tutorial HolaMundo en Java utilizando Eclipse

2007-03-23T09:50:00.000-05:00

Video Tutorial Java Jdeveloper

2007-03-23T09:43:00.000-05:00

Video Tutorial Java 8: Arrays (Arreglos)

2007-03-23T09:25:00.000-05:00

Video Tutorial Java 7: Sentencia Switch

2007-03-23T09:24:00.000-05:00

Video Tutorial Java 6: Bucles

2007-03-23T09:23:00.000-05:00

Video Tutorial Java 5: Programación Orientada a Objetos

2007-03-23T09:21:00.000-05:00

Video Tutorial Java 4: Sentencia If

2007-03-23T09:20:00.000-05:00

Video Tutorial Java 3: Variables y Aritmética (Parte 2)

2007-03-23T09:19:00.000-05:00

Video Tutorial Java 3: Variables Y Aritmética (Parte 1)

2007-03-23T09:17:00.000-05:00

Video Tutorial Java 2: Hola Mundo!

2007-03-23T09:16:00.000-05:00

Video Tutorial Java 1: Instalando Java Development Kit

2007-03-23T09:12:00.000-05:00

Usando Java Web Start en el IDE NetBeans

2007-03-22T17:12:00.000-05:00

Muestra como crear una aplicación con Java Web Start:

Creando un Modulo Plug-in con Matisse Form

2007-03-22T17:04:00.000-05:00

Creando un TopWindowComponent en NetBeans 5.0

2007-03-22T16:54:00.000-05:00

Herramientas de Código Fuente

2007-03-22T16:23:00.000-05:00

Navegación

2007-03-22T16:17:00.000-05:00

Autocompletación de código

2007-03-22T16:16:00.000-05:00

Video Tutorial ARP poisoning - Detección

2007-03-22T15:53:00.000-05:00

Para ver el video haz click aquí ;)

Video Tutorial ARP poisoning - ettercap

2007-03-22T15:51:00.000-05:00

Para ver el video haz click aquí ;)

Video Tutorial ARP poisoning - Main in the middle attack

2007-03-22T15:39:00.000-05:00

Para ver este video tutorial, click aquí ;)

¿Quieres saber cuantos usuarios están visitando en este momento tu web?

2007-03-22T11:44:00.000-05:00

Muchas veces nos gustaría saber cuantas personas están viendo nuestra web o blog, pues bien Who´s amung us, es un pequeño widget que nos facilita esta tarea. Para algunas webs es fácil implementar un programa en PHP, por ejemplo, ya que pueden utilizar su propio servidor para administrar la información de los visitantes... pero en un blog la cosa cambia, y tenemos que recurrir a otros servicios como este...

Pero, ¿que ventajas tiene Who´s amung us frente a otros servicios de Stats, contadores, etc? Pues que es fácil de instalar y además no es necesario registrarse. Basta con ir al Web Site del proyecto, copiar el código HTML que aparece en la parte inferior y pegarlo en nuestra web... eso es todo.

Editando Hints [NetBeans]

2007-03-21T17:35:00.000-05:00

Creación de una aplicación web básico [NetBeans]

2007-03-21T09:29:00.000-05:00

Creación de una aplicación en modo gráfico [NetBeans]

2007-03-21T09:28:00.000-05:00

Creación de una aplicación en modo consola [NetBeans]

2007-03-21T09:24:00.000-05:00

Cinco aplicaciones para conocer Internet de manera visual

2007-03-21T08:37:00.000-05:00

Internet es algo que se ha convertido en un concepto etéreo, difícil de visualizar más allá de un conjunto de cables y ordenadores. Sin embargo, la cartografía de Internet es tan real como interesante, y gracias a estos programas y aplicaciones web, podemos conocerla de manera atractiva y visual.

Si consultamos un mapamundi, podemos ver las fronteras de los países, e incluso podemos intuir las principales rutas de desplazamiento de mercancías y personas. Pero existe una cartografía aparentemente oculta: la de las comunicaciones digitales. Una red que se extiende a lo largo y ancho del mundo y que define las rutas que siguen nuestros correos electrónicos, mensajes de "messenger", o peticiones de navegación a servidores web.

Conozcamos 5 aplicaciones que nos ayudarán a entender cómo está construída la red y qué ruta siguen los paquetes de información. Puede que te lleves más de una sorpresa.

TouchGraph

TouchGraph es una aplicación Java que se apoya en el buscador Google para mostrarnos, de manera gráfica, los vínculos de unión entre páginas que aparecen como resultado de una búsqueda concreta. Así, si buscamos "coches clásicos", nos presentará las diferentes webs resultado de la búsqueda así como todos sus vínculos externos, pudiendo ver si existe una sinergia entre webs de la misma temática o si, por el contrario, no se relacionan.
También podremos ver relaciones entre la temática de búsqueda y empresas o instituciones que aparentemente no tienen nada que ver.

Puedes comprobar cómo funciona aquí

VisualRoute

Una de las herramientas de "cartografía" de la red que viene con nuestro sistema operativo, y que es desconocida por una gran mayoría de usuarios es el "traceroute". Se trata de trazar una ruta (de ahí el nombre) desde nuestro ordenador hasta un servidor que escojamos. El problema es que el resultado es simplemente un listado de direcciones IP, lo cual no es demasiado visual.

Gracias a el programa VisualRoute podemos realizar este tipo de trazas, pero con un resultado mucho más, valga la redundancia, visual. Gracias a un mapa, podremos ir viendo el trayecto que realiza la petición a través de servidores de todo el mundo.

Puedes descargarlo aquí

Twingly

Una de las primeras aplicaciones que ha mostrado gráficamente la blogosfera ha resultado ser un salvapantallas. Realizado por la compañía sueca Prime Labs, Twingly (sí, se llama así) nos muestra en tiempo real todos los posts que se van publicando en blogs de todo el mundo, representando cada localización por una barra tridimensional que crece dependiendo del volumen de posts en un lugar determinado.

Puedes descargarlo e instalarlo gratuitamente aquí.

Pagebull

Quizás Pagebull no sea el nombre más acertado del mundo para un buscador, pero si el portal más conocido de vídeos puede llamarse "YouTube", está todo visto. Este buscador se diferencia del resto en que te muestra los resultados de la búsqueda con miniaturas de las páginas. Así podrás intuir (más o menos) si el aspecto de la página se corresponde con lo que esperas.
Aunque claro, al no tener texto puede que sea una página preciosa sobre algo que no tiene nada que ver con lo que buscas.

Puedes comprobar si sirve para algo aquí.

Mapulator

Por último tenemos Mapulator, que no es más que una aplicación muy parecida al VisualRoute, pero que se comunica con los mapas de Google Earth. Con esta aplicación gratuita podrás ver la ruta que sigue un traceroute, además de poder obtener información concreta de cada una de las "paradas" que realiza el paquete de información para llegar a su destino.

Para ponerlo a prueba, pulsa aquí.

Fuente: Terra - Tecnología / Daniel V. González

Eclipse vs NetBeans vs IntelliJ

2007-03-16T08:34:00.000-05:00

Tin, tin, tin... que comienze el combate XDDDD

En Devx.com han publicado un artículo comparando los tres entornos de desarrollo más populares actualmente dentro de Java: Eclipse, Netbeans e IntelliJ. La comparativa hace un énfasis especial en el soporte que los entornos proporcionan para las tecnologías que emplean más comúnmente los programadores Java: Swing, JSP/Struts, JavaServer Faces y J2EE/EJB 3.0.

Segun Devx.com NetBeans es la mejor opcion a la hora de desarrollar en Swing y J2EE/EJB 3.0. Para JSP/Struts, JavaServer Faces se lo compiten entre Eclipse y IntelliJ.

Leer el articulo

I-Doser, para drogarse virtualmente

2007-03-14T12:53:00.000-05:00

Es viejo ya, pero hasta hoy me entero que existe un software de tal calaña. I-DOSER es un software que emite ondas cerebrales binaurales que recrean efectos producidos por distintos tipos de drogas. En el archivo se incluyen desde marihuana, cocaina, extasis, peyote o acido hasta heroina. Para sentir efectos deben usar audifonos.

La verdad me ha dejado anonadado, no pense ver algo asi jamas. Les dejo un screenshot de la interfaz del programa:

Es una buena experiencia para los que, como yo, nunca han consumido ningún tipo de alucinógeno y tampoco lo quieren hacer (tal vez por miedo a volverse adicto).

La pagina inicial del proyecto esta bien completa, me la imaginaba infantil o poco profesional, pero me equivoque:

Con esos links basta para que te vuelvas todo un drogadicto virtual jajaja. No, en serio: algunas personas dan fe de que el software funciona, otros dicen que solo causa fuertes dolores de cabeza, otros dicen que cura el dolor de cabeza; en fin... es mejor que lo prueben ustedes.

Por ultimo, y si tienes ciertas dudas, en la FAQ dice que NO hace daño, pero... en fin, solo pruebenlo si quieren.

Descargas:
Click aqui!! o
I-DOSER (Contraseña "larevo.org")

Pd. disculpen la falta de tildes pero aun no se manejar este nuevo teclado (configurado en Ingles).

Desklets, widgets Java para el escritorio

2007-03-13T10:03:00.000-05:00

Los desklets, término acuñado por Joshua Marinacci, son pequeñas aplicaciones de escritorio escritas en Java que permiten interaccionar directamente con servicios web. Por ejemplo, podrían permitir acceder a información sobre el tiempo en tu región, realizar búsquedas en la wikipedia o mostrar la última cotización de bolsa de una determinada compañía. La idea no es nueva: se suele reconocer como pionero a los widgets de Mac Os X y ahora también los ha incorporado Windows Vista, aunque hace mucho tiempo que el escritorio Linux tiene aplicaciones que podrían considerarse "widgets".

Joshua Marinacci ha creado un kit de desarrollo, AB5k, para la construcción de widgets multiplataforma empleando Java. El proyecto está albergado en Google . Ya han creado varios de estos dispositivos y existe una limitada cantidad de documentación.

La idea en si es buena. Pero le veo dos problemas: lo mucho que tarda una máquina virtual en arrancar y la gran cantidad de memoria que consume. A no ser que se garantice que todos los widgets se ejecuten en una misma máquina virtual (lo que podría hacer que un error en uno se propágase los demás) emplear varios de estos widgets podría consumir una cantidad de memoria ridícula. Por otro lado, no creo que se pueda competir con widgets nativos en lo referente a la velocidad de arranque. En definitiva, que quizás una aplicación Java consuma demasiados recursos para tener una tontería de aplicación en una esquina de tu escritorio...

Como crear una distribución de Linux

2007-03-13T08:56:00.000-05:00

Requisitos

35 GB de espacio en el disco duro
Un mirror con 28 GB libres (puede ser tu propio ordenador)
Tener instalado Ubuntu sin actualizaciones
Conocimientos básicos de Linux

Instrucciones

* Ve a http://svn.gnewsense.svnhopper.net/ y descarga el builder

Elige la Clave GPG

Las versiones más recientes de apt requieren una firma GPG en el repositorio de archivos para asegurar la integridad de la distribución, así que nuestro primer paso es crear una clave GPG. gpg --gen-key te permitirá hacerla, asegúrate de que la contraseña está en blanco. Necesitaras la firma de la llave para el archivo de configuración.

Finalmente, añade la clave pública en el almacén de claves.

gpg --export sudo gpg --import

Paquetes

Necesitarás los siguientes paquetes para que la distro funcione correctamente:

apt-get install reprepro imagemagick debmirror build-essential apache2 subversion cdebootstrap
apt-get install squashfs-tools netpbm syslinux bittornado
apt-get build-dep linux-image-$(uname -r) ubiquity update-manager ubuntu-artwork base-files ubuntu-meta
apt-get build-dep launchpad-integration grub system-tools-backends example-content gnome-panel
apt-get build-dep gnome-app-install
svn co http://svn.gnewsense.svnhopper.net/gnewsense/builder/trunk builder
sudo ./fixup-kernel-wedge

DebMirror (opcional)

Para evitar tener que bajar varias veces el mismo archivo, es recomendable crear un mirror único. Para lo que se necesitarán 27 gb

debmirror --nocleanup --verbose --progress --method=http --host=ie.archive.ubuntu.com --arch=i386 \
--source --dist=dapper,dapper-security,dapper-updates,dapper-backports --section=main,main/debian-installer,universe --ignore-release-gpg \
--root=ubuntu /the/target/directory

Necesitarás además configurar Apache para obtener el mirror via Http o Localhost, este paso es opcional, pero se recomienda hecerlo

Configuración

Abre el directorio builder (usa cd) que creaste anteriormente y abre el fichero config en un editor de texto. las opciones de las que te tienes que iocupar son: MIRROR, RELEASE, DISTRONAME, DOMAIN, BASEDIR, and REPOAPT.

Mirror Es el mirror que tu elegiste en el paso anterior. MIRRORDIST es el nombre del mirror. Normalmente dapper
Distroname Es el nombre de la distribución, solo puede tener números y letras
Release Es el nombre del release. Debe estar en minúsculas
Logoletter Es la letra que actuará de logo en tu distro
Tagline Se mostrará en la pantalla de inicio
DomainSe usará como fuente para obtener programas al instalar
BasedirEs el directorio bajo el que el livecd y los archivos temporales se guardarán. por lo que debería configurar apache para el directorio REPOST ($BASEDIR/(nombre de la distribución (minúsculas))).
META_*_{ADD,REMOVE}Los paquetes que quieres quitar o añadir desde el paquete ubuntu-meta mientras tus meta-paqeutes son creados.
*_VERSIONEs el número que se añade a la versión de los paquetes. Lo incrementarás a medida que rehaces la distro. lo más probable es que quieras empezar desde el 1
RSYNC_DESTEs donde se generan las reposiciones o el livecd. Se debe hacer un rsync con push-repo o push-cd.

Genera el repositorio

./gen-repo && ./do-update

Esto creará la imágen que se alojará en $LIVECDDIR/$DISTRONAME_L-livecd-$LIVECD_VERSION.iso

./gen-cdsource
./stage-cd

Advertencia:Para 32 bits, usa ./gen-repo && linux32 ./do-update

Prepara el source del tarball y pon pon la ISO en $REPODST/cdimage

Pon tu distro en un mirror y publicala

Ahora podrás publicar tu ISO, para ello, escribe lo siguiente:

./push-repo
./push-cd

Fuentes

* HowTo Create Your Own GNU Linux Distribution (Inglés)

Copyright (c) 2007 Cristian Castiblanco.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".

Sun ofrecerá soporte a la nueva generación de Plataforma Java para teléfonos móviles

2007-03-10T11:40:00.000-05:00

Pues es la noticia referente a Java más mencionada últimamente. Un pequeño resumen:

Sun Microsystems, Inc. (NASDAQ: SUNW) ha anunciado que ofrecerá soporte completo para la Arquitectura de Servicios Móviles (MSA), la nueva generación de plataforma Java para teléfonos móviles, disponible para toda la gama de productos móviles y de NetBeans Integrated Development Environment (IDE).

Sun, junto con otras 13 compañías, entre las que se encuentran operadores, OEMs y fabricantes de software, participó en el desarrollo de MSA a través del Java Community Process. El objetivo es ofrecer mayores funcionalidades de la plataforma móvil a los desarrolladores de aplicaciones y reducir las diferencias en la implementación a través de la creación de Interfaces de Programación de Aplicaciones (APIs) y clarificaciones específicas de componentes. Las nuevas capacidades de MSA permiten la creación de aplicaciones y servicios móviles atractivos. Algunos ejemplos de estas capacidades son: gráficos 3D, gestión de información personal, bluetooth, animación, servicios web, servicios de localización y de pago.

"La tecnología Java ofrece la plataforma ideal que permite crear y desarrollar aplicaciones para móviles a través de múltiples dispositivos. Presente en más de 1.500 millones de teléfonos móviles con tecnología Java en el mercado, MSA revolucionará la industria móvil al ofrecer avanzadas capacidades a los desarrolladores que les permitirán crear novedosas aplicaciones y servicios para la nueva generación de telefonía móvil" señala Laurie Tolson, vicepresidente de Client Software Group en Sun. "Además, MSA ayuda a ofrecer coherencia en la implementación de la especificación, lo cual reducirá la fragmentación del mercado. En Sun estamos encantados de dar soporte a esta nueva especificación en todas nuestras ofertas para dispositivos móviles."

Los productos de Sun que soportan MSA incluyen:

Sun Java Wireless Client: implementación optimizada de la plataforma Java para móviles con soporte multitarea para permitir múltiples aplicaciones concurrentes. Esta implementación está disponible en ambas soluciones fuente y binarias.

Sun Java Device Test Suite 2.0: una suite de pruebas que ayuda a evaluar la calidad y funcionalidad de las implementaciones Java ME para móviles.

NetBeans Mobility Pack 5.5: basado en el premiado Entorno de Desarrollo Integrado Net Beans de código abierto (Net Beans Integrated Development Environment - IDE), el plug-in de desarrollo Java ME ofrece un nuevo nivel de sofistificación con un sencillo diseño, además de soporte para entornos y aplicaciones móviles preparados para animación y servicios web y entornos de emulación de dispositivos, como el Sun Java Wireless Toolkit para la Configuración Limitada de Dispositivos Conectados (Connected Limited Device Configuration : CLDC).

Sun Java Wireless Toolkit 2.5 para Connected Limited Device Configuration (CLDC): un premiado kit de desarrollo de software que contiene las herramientas de desarrollo, utilidades, y un entorno de emulación de plataforma inalámbrica que pemite a los desarrolladores construir y testar sus aplicaciones.

Además de estos productos, Sun también incluye en el proyecto phoneME de la comunidad Mobile & Embedded en Java.net (http://community.java.net/mobileandembedded/) el código fuente para las más avanzadas implementaciones Java ME en móviles, que soportan MSA.

Sun ha lanzado estas tecnologías bajo licencia open source para acelerar el desarrollo y la evolución de la plataforma, reducir la fragmentación y los costes de desarrollo a través del ecosistema Java ME. Además, este movimiento ofrece un fácil acceso a las últimas versiones de las tecnologías de plataforma Java ME , y, por primera vez, permite a toda la comunidad Java ME seguir las actividades y participar en el desarrollo de estas tecnologías.

Ver más información sobre MSA

Mañana me voy de conferencia

2007-03-08T16:18:00.000-05:00

Invitados estan!!!Conferencia Windows Small Business Server 2003 R2 en OWAHA. Metiendome en el mundo del software privativo, pero solo para "conocer", mi vida es del software libre!!!

elhacker.net: más o menos online

2007-03-07T15:35:00.000-05:00

Pues ya hace bastante tiempo el foro de elhacker.net ha estado sometido a un ataque DoS... aquí se explica mejor todo lo que está pasando. La razón del ataque es más que obvia: la envidia tan hijueputa que le tienen a esta maravillosa web. El autor principal del ataque es... mejor ni decir nombres: eso sería hacerle propaganda a lammers CRIMINALES.

En fín, después de intentar una y otra cosa entre la gente del staff (y tratando de colaborar en lo poco que puedo) se tiene PROVISIONALMENTE un mecanismo de proxys que contrarrestará temporalmente el ataque. Solo queda esperar y tener paciencia.

El foro y la web volverán!!! No estamos afuera y nunca lo vamos a estar!!!

Programación C++ sobre Linux

2007-03-03T14:51:00.000-05:00

Este artículo pretende orientar un poco acerca de lo que es la programación en C++ sobre linux. Esto NO es un tutorial de referencia de C++, si lo que buscas es eso puedes buscar en el google que hay bastantes. Posiblemente ya hayas programado en C++ sobre Windows, y has utilizado algún compilador como el C++ Builder de Borland, el Visual Studio de Microsoft o en el mejor de los casos DevC++.

Ok, esto es un buen comienzo. Pero lo que aquí vamos a ver es: qué nos proporciona Linux para programar en C++. Como sabes en Linux las cosas ya no son tan fáciles, pero tampoco difÃciles; de hecho C++ es famoso gracias a Linux, son como uña y mugre. La cuestión es que nos centraremos en la programación desde la consola. Si lo tuyo no es la consola puedes echarle un vistazo a la sección que trata sobre Anjuta, que es un IDE para C++ en Linux, pero te recomiendo que leas todo el artículo, te aseguro que te servirá.

Vamos a tratar los siguientes temas (y talvez algunos más):

Esta es realmente la base de la programación en C++: cruda, sin vestimentos, tal como es.

Descargar el tutorial completo en PDF

Editores de texto en Linux

2007-03-02T20:02:00.000-05:00

Como ya debes saber, lo primero que necesitamos para programar es un editor de texto. Uno de los primeros resultados del proyecto GNU fue el editor emacs, y los editores estuvieron entre los primeros programas que se portaron a Linux.

Pero vamos a centrar nuestra atención en el editor vim, el cual es básicamente una interfaz basada en pantallas escrita con base en ex (otro editor muy antiguo).

En la mayoría de los distros de Linux encontrarás el editor vim. Aunque muchas personas piensan que vim es enigmático y difícil de utilizar, por lo general es porque nos acostumbramos al bloc de notas de Windows, emacs (en modo gráfico) y/o a los IDE's (a lo fácil); sin embargo, vim tiene muchas ventajas con respecto a otros editores:

Está disponible en prácticamente en todos los sistemas UNIX y Linux.
Necesita menos recursos de sistema que emacs, y por consecuencia se ejecuta aunque el sistema no esté funcionando completamente.
No es tan personalizable como el emacs, por lo que sus implementaciones se comportan casi de la misma manera.

Puedes utilizar cualquier otro editor de texto, aunque te recomiendo que domines los fundamentos del vim. Para comenzar puedes leerte este pequeño (muy pequeño) artículo acerca del vim.

ctags y etags

Al codificar un programa grande en C++, talvez sea necesario dividir las clases y métodos en archivos fuente separados. Pero después, al depurar el programa, puede resultar tediosa la tarea de navegar entre archivos. Por ejemplo, talvez esté editando el archivo A y en él haya una invocación a un método que se encuentre en otro fichero, talvez el B. Los programas ctags y etags generan archivos índice o “tag”, que vi y emacs pueden utilizar para ayudarlo a navegar por sus archivos fuente.

ctags genera marcas para vim, pero se puede configurar para que lo haga para emacs. etags genera marcas para emacs, pero se puede configurar para que lo haga para vim.

Vamos a ver un ejemplo del ctag con vim. Para ello escribimos el siguiente código en un archivo llamado HolaPrincipal.cpp:

//HolaPrincipal.cpp
#include<iostream>
using namespace std;
void Saludar(int i);
int main(int argc, char * argv[])
{
    for(int i=0; i<5; i++)
    {
       Saludar(i);
       cout<<endl;
    }
}

y lo siguiente en Saludar.cpp:

//Saludar.cpp
#include<iostream>
using namespace std;
void Saludar(int i)
{
cout<<"["<<i<<"] elhackerr00lz";
}

Ahora vamos al directorio donde tenemos los dos archivos y escribimos el comando:

ctags *.cpp

Hemos creado el nuevo archivo tags. Ahora vamos a probarlo, para ello abrimos el archivo HolaPrincipal.cpp (vim HolaPrincipal.cpp); y usando las flechitas de dirección colocamos el cursor sobre la palabra Saludar. Oprime Ctrl+], y verás que el editor abre automáticamente el archivo que contiene la función (Saludar.cpp) y coloca el cursor al inicio de la misma.

Como he dicho anteriormente solo centraremos la atención al vim, para el emacs puedes manejar tanto el ctags como el etags. Utiliza la información en línea para ver como se utiliza.

Indice | siguiente>>

Compiladores de C/C++ en Linux

2007-03-02T19:46:00.000-05:00

El compilador C de GNU se llama gcc y puede compilar C, C++ y Objective-C. El compilador de C se apega al estándar ANSI, por lo que es fácil de portar un programa C ANSI a Linux.

Cómo compilar con gcc

El compilador GNU se invoca con el comando gcc. De manera predeterminada este comando preprocesará, compilará y en enlazará un programa de C. Existen muchas opciones para el gcc, y entre ellas existen controles que permiten ejecutar solo alguna fase de la secuencia preproceso/compilación/enlace.

El siguiente ejemplo sencillo es un programa en C que simula el lanzamiento de un dado n veces, y luego imprime el nÃºmero de veces que sale cada una de sus caras. Nota: El ejemplo lo saqué de un libro de C, espero no me demanden.

Crea el archivo juego.c:

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

int tirarDado(void);

int main(int argc, char * argv[])
{
    int i, iIter, dado[6];

    if(argc<2)
    {
printf("Uso: %s n\n",argv[0]);
        return 1;
    }
    iIter = atoi(argv[1]);
    memset(dado, 0, sizeof(dado));
    for(i=0; i<iIter; i++)
    {
       dado[tirarDado() - 1]++;
    }
    printf("%d tiradas\n",iIter);
    printf("\tCara\tTiradas\n");
    for(i=0; i<6; i++)
    {
       printf("\t%d : \t%d\n",i+1, dado[i]);
    }
}

Y el archivo tirador.c:

#include<stdlib.h>
int tirarDado(void)
{
return (rand()%6+1);
}

PodrÃamos utilizar un solo comando para compilar y crear el programa ejecutable:

gcc -o juego juego.c tirador.c

Puede ver que -o indica el nombre del archivo de salida (el ejecutable). gcc sabe que los archivos con la extensión *.c son archivos de C y los compila como tales. Sino especifica un nombre de archivo de salida, gcc creará predeterminadamente el archivo a.out.

Ahora veamos otra manera de compilar nuestro programa: haciÃ©ndolo por módulos (por separado):

gcc -c juego.c
gcc -c tirador.c
gcc -o juego juego.o tirador.o

En este caso indicamos al compilador, con la opciÃ³n -c, que primero el archivo juego.c, luego el archivo tirador.c. Y por último le indicamos que cree el archivo binario ejecutable, utilizando los dos archivos objeto (resultados de la compilación): juego.o y tirador.o.

Cómo compilar con g++

El comando g++ nos permite compilar archivos de C++. Aunque gcc puede compilar programas de C++, no hace automáticamente todos los enlaces requeridos con las bibliotecas de clases. Necesita usar g++ para esto. Por ello es recomendable que utilices g++ si estás utilizando C++.

Ahora vamos a compilar la versión C++ de nuestro programa de los dados; el archivo juego.cpp:

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
int tirarDado(void);

int main(int argc, char * argv[])
{
    int i, iIter, dado[6];

    if(argc<2)
    {
       cout<<"Uso: "<<argv[0]<<"n\n";
        return 1;
    }
    iIter = atoi(argv[1]);
    memset(dado, 0, sizeof(dado));
    for(i=0; i<iIter; i++)
    {
       dado[tirarDado() - 1]++;
    }
   cout<<iIter<<" tiradas\n";
    cout<<"\tCara\tTiradas\n";
    for(i=0; i<6; i++)
    {
       cout<<"\t"<<i+1<<" :\t"<<dado[i]<<endl;
    }
}

El archivo tirador.cpp:

#include<stdlib.h>
int tirarDado(void)
{
return (rand()%6+1);
}

La compilación en g++ es muy similar a gcc en casi todos los aspectos. Para compilar con un solo comando utiliza:

g++ -o juego juego.cpp tirador.cpp

Y para compilar por módulos:

g++ -c juego.cpp
g++ -c tirador.cpp
g++ -o juego juego.o tirador.o

ELF
Cuando se compila un programa, se genera un archivo objeto, y cuando se enlaza el programa, se crea un archivo binario ejecutable. El enlazador debe entender el formato de los archivos objeto, y como el sistema operativo debe cargar y ejecutar el programa ejecutable, también debe entender este formato.
Ya vio que el archivo ejecutable por defecto se llama a.out. Hace un tiempo, el formato de los archivos objeto y los archivos ejecutables se conocía como a.out. Este formato es muy antiguo y contiene bastantes defectos. El formato actual, utilizado por los sistemas UNIX y Linux se conoce como ELF (Formato Ejecutable y de Enlace). ELF es mucho más versátil que a.out, y se presta muy bien para crear bibliotecas compartidas (librerías dinámicas).

Puede saber cual es el formato de un archivo utilizando el comando file, por ej.:

file juego tirador.o /usr/bin/apt-get
juego: ELF 32-bit LSB executable, Intel 80386...
tirador.o: ELF 32-bit LSB relocatable, Intel 80386...
/usr/bin/apt-get: ELF 32-bit LSB executable, Intel 80386...

<<anterior | siguiente>>
Indice

Bibliotecas compartidas de C++ en Linux

2007-03-02T18:30:00.000-05:00

A veces, varios programas necesitan hacer las mismas cosas, como E/S por ejemplo. Hace ya bastante tiempo se desarrolló el concepto de biblioteca (o librería) para adaptar esto. Las funciones se colocan en un archivo, y luego, cada vez que se crea un programa, este extrae de la biblioteca las funciones que necesita.

En su momento, esto fue un gran avance, pero tenía varias desventajas. Los ejecutables se hacen más grandes ya que cada uno de ellos incrusta código copiado de las bibliotecas. Si se encuentra un error en la biblioteca o se agrega una característica, el ejecutable no hace uso de ella a menos que se vuelva a crear.

La solución a esto son las bibliotecas compartidas (o librerías dinámicas). El mecanismo de las bibliotecas compartidas esta fuera del alcance de este artículo. Solo veremos como crearlas y utilizarlas.

Regresemos al programa del dado que hicimos en C. Este programa tiene dos archivos fuente. Supongamos que nuestra función tirarDado (del archivo tirador.c) nos es muy útil, no solo en nuestro programa, sino en muchos otros programas que utilicen dados. Podemos pensar entonces en colocar dicha función en una biblioteca para que otros programas puedan usarla.

Primero necesitamos crear la biblioteca compartida. Para ello compilamos el archivo que contiene la función así:

gcc -fPIC -c tirador.c

Ahora lo convertimos en una biblioteca compartida llamada libtirar.so.1.0:

gcc -shared -Wl,-soname,libtirar.so.1 -o libtirar.so.1.0 tirador.o

Por último crearemos un enlace para libtirar.so, para que el programa en ejecución no necesite mantener un registro de la información de versión en el nombre de la biblioteca compartida:

ln -s libtirar.so.1.0 libtirar.so.1
ln -s libtirar.so.1 libtirar.so

Ahora que tenemos la biblioteca, debemos crear el programa principal para que enlace con esa biblioteca en tiempo de ejecución, en lugar de incluir el código dentro del ejecutable:

gcc -o juego juego.c -L. -ltirar

La opción -L. le indica al compilador que busque bibliotecas en el directorio actual, y la opción -ltirar le indica que busque una biblioteca llamada libtirar.so.

Al ejecutar el programa, el sistema operativo cargará dinámicamente la biblioteca correcta, pero tiene que saber donde buscarla. Si la biblioteca no se encuentra en un lugar estándar (/usr/lib por ejemplo), puede asignar una variable de entorno para que le indique en dónde localizar bibliotecas adicionales:

export LD_LIBRARY_PATH=/home/usuario/mislibrerias

Por último, para ver qué librerías usa un programa, utilice el comando ldd:

ldd juego
    libtirar.so.1 =>/mnt/hda1/home/casidiablo/juegolibrerias/libtirar.so.1 (0x40018000)
    libc.so.6 => /lib/libc.so.6 (0x40029000)
    /lib/ld-linux.so.2 =>/lib/ld-linux.so.2 (0x40000000)

Otro ejemplo de bibliotecas... crear una biblioteca estática

A diferencia de las bibliotecas compartidas, al momento de compilar bibliotecas estáticas, se incluyen en el programa las rutinas que utiliza de la biblioteca; en otras palabras las rutinas están insertas en el programa sin la posibilidad de ser utilizados por otro programa. Nuestra demostración se basará en la construcción de una biblioteca estática; dentro de nuestra biblioteca incluiremos un procedimiento que imprimirá un mensaje en pantalla el que será pasado por parámetro y una función que nos entrega en cálculo del factorial de un numero dado (pasado por parámetro); para que luego estas rutinas sean llamadas desde un programa de ejemplo.

El proceso para crear bibliotecas estáticas es escribir el código fuente, compilar a código objeto el fuente y crear la biblioteca con los archivos objetos. A continuación procederemos a escribir nuestras rutinas que serán incluidas en la biblioteca, los archivo de las rutinas serán factorial.c e imprimir.c

//imprimir.c
#include<stdio.h>
void imprimir_en_pantalla(const char* mensaje)
{
printf("%s",mensaje);
}

//factorial.c
#include<stdio.h>
long factorial(long numero)
{
        if(numero>0)
                return numero * factorial(numero-1);
        else return 1;
}

Ahora compilaremos estos archivos fuente y los convertiremos en código objeto utilizando gcc:

gcc -c imprimir.c factorial.c

Esto creará los archivos objeto (imprimir.o y factorial.o). El siguiente paso será crear nuestra biblioteca estática con estos archivos de código objeto; a la biblioteca la llamaremos libejemploestatica.a:

ar rsc libejemploestatica.a imprimir.o factorial.o

El comando ar creará nuestra biblioteca (opcion c), introducirá los archivos objeto al archivo creado (opción r) y por último creará un índice de los módulos (opción s), esto último permite que el linker (ld) al momento de compilar (ld es llamado por gcc) no tenga que leerse toda la biblioteca completa ya que se agregan los índices y descripción de los módulos. El proceso de crear el índice de los módulos también se pude realizar con ranlib.

//miprograma.c
#include<stdio.h>
#include "libejemploestatica.h"
int main()
{
        printf("Programa de ejemplo de utilizacion de biblioteca\n");
        imprimir_en_pantalla("Vamos a calcular un factorial\n");
        printf("El valor del factorial de 4 es: %i\n",factorial(4));
}

Ahora nos falta crear nuestro archivo de cabecera (header), que son los que tienen terminación .h, en este archivo se incluirán las llamadas a las rutinas de la biblioteca y es una manera elegante porque también puedes incluir estas llamadas en el programa que las vas utilizar. El archivo de cabecera libejemploestatica.h tendrá el siguiente contenido:

extern void imprimir_en_pantalla(const char*);
extern long fatorial(long);

No es necesario que el archivo de cabecera y biblioteca sean iguales antes de la extensión. Ahora crearemos el archivo ejecutable en base a nuestro programa principal (miprograma.c), el cual utilizará la biblioteca que hemos creado. Para ello debemos compilarlo utilizando la biblioteca:

gcc -o programa_ejecutable miprograma.c -L. -lejemploestatica

Con la opción -L indicamos donde se encuentra nuestro archivo de cabecera, como en este se encuentra en el mismo directorio utilizamos el punto (-L.). Con la opción -l indicamos el nombre de la librería. Fíjate que no es necesario colocar el nombre completo (libejemploestatica) ya que gcc asume que los nombre de bibliotecas empiezan con el prefijo "lib". Ahora ya tendremos el archivo ejecutable listo para correr nuestro programa:

$ ./programa_ejecutable
Programa de ejemplo de utilizacion de biblioteca
Vamos a calcular un factorial
El valor del factorial de 4 es: 24

<<anterior | siguiente>>
Indice

Construcción o creación (uso del comando make)

2007-03-02T18:01:00.000-05:00

Cuando creamos pequeños programas como los que hemos hecho hasta ahora, no resulta muy difÃcil el proceso de compilación y enlace. Pero cuando se crean proyectos grandes, con varios archivos fuente (15, 30 o más) y librerías resultaría muy difícil o hasta imposible.

Linux viene con la utilería make de GNU. make lee de un archivo conocido como make toda la información que necesita para crear su programa. Ésta utilería es tan importante y popular que se ha especificado como estándar de POSIX.

make

make de GNU busca automáticamente un archivo make llamado GNUmakefile. Sino lo encuentra, busca makefile, y si tampoco lo encuentra busca Makefile, y si tampoco lo encuentra dice “que mierdas, no juegues conmigo que no me gusta perder tiempo” XD. Estos son los nombres predeterminados, pero puedes crear un archivo con el nombre que quieras y especificar al make que lo utilice. Los archivos make contienen información acerca de la compilación y enlace de su programa, con una sintaxis muy específica que make puede entender.

make tiene una gran variedad de reglas integradas. Por ejemplo, sabe que los archivos que terminan con .c son archivos fuente de C, y sabe cómo compilarlos para convertirlos en archivos objeto (.o). Puedes redefinir cualquiera de estas reglas si gustas. En el caso más simple, todo lo que necesitas especificar en tu archivo make es el nombre que va a tener su archivo ejecutable, así como los archivos .o que se necesitan para crearlo.

He aquí un archivo sencillo para make, que creará el programa de los dados:

juego:juego.o tirador.o
$(CC) -o $@ juego.o tirador.o

Ahora podrás crear el programa con tan solo un comando: make.

Hay ocasiones en las que hay que indicar como compilar cierto tipo de archivo, por ejemplo cuando se utilizan otro tipo de extensiones (.cpp, .cxx, .c++). El error que se generaría sería similar a este:

make: *** No hay ninguna regla para construir el objetivo 'juego.o', necesario para 'juego'. Alto.

Vamos a ver un ejemplo de archivo makefile en donde se especifica explícitamente como construir dichos archivos objeto:

juegodados: juego.o tirador.o
    $(CC) -o $@ juego.o tirador.o

juego.o: juego.c
    $(CC) -c juego.c

tirador.o: tirador.c
    $(CC) -c tirador.c

Ahora veamos un archivo makefile aún más completo:

#Makefile para crear programa para tirar dados
CFLAGS = -O

OBJS = juego.o tirador.o

all=dado

juego: $(OBJS)
    $(CC) $(CFLAGS) -o $@ $(OBJS)

juego.o: juego.c
    $(CC) -c juego.c

tirador.o: tirador.c
    $(CC) -c tirador.c

clean:
    -$(RM) dado *.o

Este archivo make define una regla llamada clean, que se utiliza para eliminar todos los archivos previamente compilados (incluso el ejecutable) y empezar con un directorio limpio. Fíjate tambiÃ©n que se pueden declarar una especie de variables (como CFLAGS, OBJS, etc.), que se pueden utilizar al momento de indicar algún comando. Además fíjate que se pueden utilizar comentarios con el símbolo #.

Y un último ejemplo más complejo no nos vendría mal. Vamos a ver como sería nuestro archivo makefile, si deseÃ¡ramos utilizar bibliotecas compartidas (librerías dinámicas):

#Makefile para crear programa para tirar dados
#usando bibliotecas compartidas

CFLAGS = -O

OBJS = juego.o

LIBS=libtirar.so

all=dado

juego: $(OBJS) $(LIBS)
    $(CC) $(CFLAGS) -o $@ $(OBJS) -L. -ltirar

juego.o: juego.c
    $(CC) -c juego.c

tirador.o: tirador.c
    $(CC) -fPIC -c $<

libtirar.so: tirador.o
    -$(RM) libtirar*
        $(CC) -shared -Wl,-soname,libtirar.so.1 \
    -o libtirar.so.1.0 $<
        ln -slibtirar.so.1.0 libtirar.so.1
        ln -slibtirar.so.1 libtirar.so
clean:
    -$(RM) dado *.o libtirar*

Importante!!!
Sino quieres tener problemas en el futuro lee esto: la sintaxis de make nos obliga a respetar los separadores. ¿qué son separadores? talvez te hayas fijado en la forma en que están tabulados los archivos. Esto no es maña mÃa ni mucho menos, esto es una regla para los archivos make; sino se tabularan lo más seguro es que en la ejecución del make apareciera este error:

makefile:2: *** falta un separador. Alto.

Así que por lo que más quieras: utiliza los separadores si quieres que funcione.

Opciones de línea de comandos de make

make tiene varias opciones útiles de línea de comandos. Por ej., si quieres especificar un archivo make alternativo, en lugar de los predeterminados, invoca a make de la siguiente forma:

make -f nombrearchivo

make es un programa muy sofisticado. Una de las cosas que hace es comprender las dependencias. Por ejemplo, sabe que los archivos .o se crean a partir de archivos .c. Tu programa puede consistir en varios archivos fuente .c. Si cambias uno, no es necesario volver a compilarlos todos cada vez que vayas a crearlo. Sólo necesitas volver a compilar el archivo fuente que haya cambiado. make comprende esto y compila solo aquellos archivos que no estén actualizados. Algunas veces será necesario que veas primero qué es lo que make necesita para crear el programa. Puedes hacer esto con el siguiente comando:
make -n
Esto le indica a make que analice el makefile y que reporte qué comandos emitirá para crear el programa. make no ejecutará ningún comando.

<<anterior | siguiente>>
Indice

Depuración de programas en Linux

2007-03-02T16:51:00.000-05:00

Todo buen entorno de desarrollo debe proporcionar la capacidad de depurar nuestros programas, por ello Linux posee una herramienta llamada gdb. gdb es una excelente herramienta de depuración con interfaz de línea de comandos (modo texto). Aunque existen herramientas como gdbtui que es una versión del mismo depurador con una interfaz más amigable (pero en modo texto también). Y si sos de los que les da pereza la consola, tranquilo, también existe una herramienta llamada xxgdb que es una versión del gdb con interfaz gráfica que se ejecuta en X Windows.

gdb

gdb le permite analizar el funcionamiento de un programa paso a paso, establecer puntos de interrupción (breakpoints), examinar y modificar variables por su nombre. Se puede utilizar tanto en programas de C como de C++. Si has manejado alguna vez depuradores y debuggers como el OllyDbg, el manejo de este se te hará realmente fácil.

Para preparar un programa para su depuración, es necesario compilarlo con la opción -g. Esto hace que en alguna parte del ejecutable, se guarde información del código fuente tal como es. De otra forma no prodrás usar el depurador de forma óptima. Si estás utilizando el make para crear los programas, puedes indicar esta opción en la variable CFLAGS (¿la recuerdas?), desde la línea de comandos así:

make CFLAGS=-g

Cuando hayas creado el programa, puedes comenzar la sesión de depuración con el comando: gdb dado. (Suponiendo que el ejecutable se llama dado):

GNU gdb 6.1-debian
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-linux"...
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb)

Estamos frente al prompt del gdb, que se representa con los caracteres (gdb), indicándonos que podemos escribir los comandos a ejecutar. gdb tiene muchos comando disponibles, para verlos digita el siguiente comando:

(gdb) help

Como puedes observar, el comando help despliega la lista de clases de comandos existentes en el gdb, para ver las instrucciones de determinada clase de comandos, digita help seguido del nombre del comando, por ejemplo así:

(gdb) help breakpoints

Por último para salir del gdb presiona la tecla q. A continuación veremos una tabla con comandos más útiles para el gdb:

Comando	Función
break [nombrearhivo:]función	Establecer un punto de interrupción en la entrada a la función del archivo llamado nombrearchivo.
run [listaargumentos]	Iniciar el programa, y pasarle argumentos si es necesario.
bt	Desplegar la pila del programa.
print expre	Evaluar la expresión e imprimir el resultado. La expresión puede ser un nombre de variable o una función que retorne un valor.
c cont	Cualquiera de estos dos comandos, continÃºan con la ejecución del programa desde le punto actual.
next	Ejecutar la siguiente línea de l programa. Si la siguiente línea es una función, dicha función se ejecutará y el programa se detendrÃ¡ en la siguiente línea después de la llamada a la función.
step	Ejecutar la siguiente línea del programa, y entrar a la función si esa es una línea de función.
help [nombre]	Mostrar la ayuda general, o mostrar la ayuda específica a [nombre] si se indico uno.
q	salir del gdb.

Sesión de ejemplo de depuración con gdb

Ahora vamos a ver un ejemplo de como trabaja esta herramienta. Habiendo creado ya el programa (el de los dados) con la opción -g así:

g++ -g -o dados *.c

Pasamos a correr el depurador:

gdb dados

Con lo que aparece lo siguiente:

GNU gdb 6.1-debian
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-linux"...Using host libthread_db library "/lib/libthread_db.so.1".

(gdb)

Vamos entonces a ver el código fuente de nuestro programa principal (el que contiene la función main), esto lo hacemos con el comando list y le indicamos de que línea a que línea queremos ver, en este caso de la 1 a la 25:

(gdb) list 1,25
1    #include<stdio.h>
2    #include<stdlib.h>
3    #include<string.h>
4
5    int tirarDado(void);
6
7    int main(int argc, char * argv[])
8    {
9        int i, iIter, dado[6];
10
11        if(argc<2)
12        {
13           printf("Uso: %s n\n",argv[0]);
14           return 1;
15        }
16        iIter = atoi(argv[1]);
17        memset(dado, 0, sizeof(dado));
18        for(i=0; i<iIter; i++)
19        {
20           dado[tirarDado() - 1]++;
21        }
22       printf("%d tiradas\n",iIter);
23       printf("\tCara\tTiradas\n");
24       for(i=0; i<6; i++)
25        {

Ahora establecemos un punto de interrupción (breakpoint), en la línea 16 (iIter = atoi(argv[1]);), que hará que le programa se detenga en este punto al correrlo:

(gdb) break 16
Breakpoint 1 at 0x804850b: file juego.c, line 16.

Corremos el programa con el comando run seguido de los argumentos:

(gdb) run 5
Starting program: /mnt/hda2/archivos/programas C/juego/dados 5

Breakpoint 1, main (argc=2, argv=0xbffffd24) at juego.c:16
16 iIter = atoi(argv[1]);
Current language: auto; currently c++

Y vemos como se ejecuta, y posteriormente para en la línea 16. Nos muestra el nombre de la función en donde nos encontramos (en este caso main), y nos muestra el trozo de código fuente. Ahora veamos el valor de la variable iIter, utilizando el comando print iIter. Es de resaltar que utilizamos el nombre real de la variable para referirnos a esta, y que al estar sobre la línea en el cual se asigna el valor a la variable, el valor que nos imprime es el de la variable sin inicializar:

(gdb) print iIter
$1 = -1073742556

Veamos entonces que pasa si saltamos a la siguiente instrucción, y volvemos a imprimir el valor de iIter:

(gdb) next
17 memset(dado, 0, sizeof(dado));
(gdb) print iIter
$2 = 5

En este caso si se imprime el valor actual de la variable iIter (5). Avancemos hasta la línea 20, y observemos que podemos utilizar print para imprimir el valor de retorno de una función:

(gdb) next
18 for(i=0; i<iIter; i++)
(gdb) next
20 dado[tirarDado() - 1]++;
(gdb) print tirarDado()
$3 = 2

Ahora observemos que al estar aún dentro del for, al terminar la línea 20 el gdb nos devuelve automáticamente hasta la línea 18 (que es donde se evalua la condición del for):

(gdb) next
18 for(i=0; i<iIter; i++)
(gdb) next
20 dado[tirarDado() - 1]++;

Ahora continuemos con la ejecución normal del programa y salgamos del gdb, para ello digitamos el comando cont y después q:

(gdb) cont
Continuing.
5 tiradas
    Cara   Tiradas
    1 :     0
    2 :     2
    3 :     0
    4 :     1
    5 :     1
    6 :     1

Program exited normally.
(gdb) q

Eso es todo!!! Fácil ¿no? para un manejo avanzado del gdb leer la documentación del programa localmente (comando man) o en Internet.

<<anterior | siguiente>>
Indice

Control de versiones con RCS y CVS

2007-03-02T15:56:00.000-05:00

Los programas nunca son tan fáciles como se piensa que son al principio. Cualquier buen programa va más allá de su propósito original. Con el tiempo hay cambios, se agregan cosas, se solucionan errores y se hacen mejoras.

Los comentarios son una buena manera de mantener información acerca de los cambios, pero para cualquier trabajo serio se necesita alguna forma de control de versiones. Supongamos que cambias el programa juego.c, agregándole varias características. Un año después, tu cliente más importante te llama y te dice que no quiere todas esas características: que quiere la versión original del año pasado, en la que se había arreglado un error.

En Linux existe RCS (Sistema de Control de Revisiones). RCS es una colección de comandos que le permiten rastrear cambios realizados en archivos, recuperar cualquier versión anterior y comparar las versiones actuales con las más antiguas.

RCS

Los principales comandos de la suite RCS se muestran a continuación:

ci: Insertar en el depósito una nueva versión de un archivo.
co: Obtener la última versión de un archivo.
ident: Buscar identificadores de RCS en archivos.
merge: Crear una versión de un archivo que incorpore cambios de otras dos versiones de ese archivo.
rcsdiff: Comparar dos versiones de un archivo.
rlog: Ver el historial de un archivo.

RCS mantiene en un depósito el historial de las revisiones de los archivos. Por lo general, ese depósito es un directorio llamado RCS, que se encuentra en su directorio actual.

En el siguiente ejemplo, iniciamos el historial de RCS de un archivo en nuestro proyecto de tirar dados:

$ ci makefile
RCS/makefile,v <-- makefile
Enter description, terminated with single '.' or end file:
NOTE: This is NOT the log message!
>> Makefile del programa de tirar dados
>> .
initial version 1.1
done
$

Ahora hemos registrado el Makefile en el depósito de RCS, y RCS ha creado un archivo en el directorio RCS llamado Makefile,v. A medida que modifiquemos el Makefile y verifiquemos las versiones más recientes, RCS levará el registro de esos cambios en su copia Makefile,v.

Nota: Después de registrar un archivo en RCS, verás que tu archivo original ha desaparecido. No te asustes (gallina), no lo has perdido. RCS ha rastreado sus cambios en su copia y ha eliminado su original. Aún puede revisar su archivo con el comando co.

Registra todos los archivos necesarios para crear el programa de los dados, con los comandos ci juego.c y ci tirador.c.

$ ci *.c
RCS/juego.c,v <-- juego.c
Enter description, terminated with single '.' or end file:
NOTE: This is NOT the log message!
>> Archivo principal del programa tirar dados
>> .
initial version 1.1
done
RCS/tirador.c,v <-- tirador.c
Enter description, terminated with single '.' or end file:
NOTE: This is NOT the log message!
>> Archivo que contiene implementacion de la funcion tirardado()
>> .
initial version 1.1
done
$ ls
RCS
$

Piensa en RCS como si fuera una biblioteca que guarda tus archivos. Puedes sacar copias de solo lectura con el comando co nombrearchivo. Cuando quieras modificar un archivo, puedes sacar un copia el la que se pueda escribir (bloqueada) con co -l. Puedes sacar cualquier cantidad de copias de sólo lectura (desbloquedas) a la vez. Sólo puedes sacar una copia bloqueada a la vez. Por ejemplo:

$ co ./juego.c
./RCS/juego.c,v --> ./juego.c
revisison 1.1
done

$ ls -l
total 8
-r--r--r-- 1 root root 466 2007-02-28 14:41 juego.c
drwxr-xr-x 2 root root 4096 2007-02-28 14:37 RCS

En este caso sacamos el archivo juego.c como solo lectura. Si utilizamos el comando ls -l veremos en la parte de permisos -r--r--r-- lo que quiere decir que no podemos editar dicho archivo.

Hay varias palabras reservadas de identificación que puedes colocar en tu archivo y que son reconocidas por RCS. Estas palabras reservadas empiezan y terminan con $. Podriamos, por ejemplo, modificar el programa juego.c así:

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

int tirarDado(void);

int main(int argc, char * argv[])
{
        int i, iIter, dado[6];

        if(argc<2)
        {
                printf("Uso: %s n\n",argv[0]);
                return 1;
        }
        iIter = atoi(argv[1]);
        memset(dado, 0, sizeof(dado));
        for(i=0; i<iIter; i++)
        {
                dado[tirarDado() - 1]++;
        }
        printf("%d tiradas\n",iIter);
        printf("\tCara\tTiradas\n");
        for(i=0; i<6; i++)
        {
                printf("\t%d : \t%d\n",i+1, dado[i]);
        }
        printf("$Header$\n");
}

Para ello tendría que sacar el archivo bloqueado (con permisos de escritura), así:

$ co -l ./juego.c
./RCS/juego.c,v --> ./juego.c
revisison 1.1 (locked)
done

$ ls -l
total 8
-rw-r--r-- 1 root root 466 2007-02-28 14:43 juego.c
drwxr-xr-x 2 root root 4096 2007-02-28 14:43 RCS

Ahora sí podemos editar el archivo, ya que tiene permisos de lectura/escritura. Observemos que cuando saco el archivo desbloqueado (sólo lectura), RCS reemplaza la palabra reservada $Header$ con información acerca del nombre y la versión del archivo. Cuando lo saco bloqueado, RCS no reemplaza el encabezado.

Por último meto de nuevo el programa juego.c (ya modificado), creo el programa y lo ejecuto:

ci ./juego.c
./RCS/juego.c,v <-- ./juego.c
new revision: 1.2; previous revision: 1.1
enter log message, terminated with single '.' or end of file:
>> Le he agregado el Header
>> .
done

$ ls
RCS

$ make
co RCS/makefile,v makefile
RCS/makefile,v --> makefile
revision 1.1
done
co RCS/juego.c,v juego.c
RCS/juego.c,v --> juego.c
revision 1.2
done
cc -c juego.c
co RCS/tirador.c,v tirador.c
RCS/tirador.c,v --> tirador.c
revision 1.1
done
cc -c tirador.c
cc -O -o juego juego.o tirador.o

$ ls -l
total 40
-rwxr-xr-x  1 root   root    12689 2007-02-28 14:52 juego
-r--r--r--  1 root   root     562 2007-02-28 14:52 juego.c
-rw-r--r--  1 root   root     1368 2007-02-28 14:52 juego.o
-r--r--r--  1 root   root     247 2007-02-28 14:52 makefile
drwxr-xr-x  2 root   root     4096 2007-02-28 14:46 RCS
-r--r--r--  1 root   root      65 2007-02-28 14:52 tirador.c
-rw-r--r--  1 root   root     804 2007-02-28 14:52 tirador.o

$ ./juego 130
130 tiradas
    Cara    Tiradas
    1 :     18
    2 :     22
    3 :     28
    4 :     27
    5 :     17
    6 :     18
$Header: /mnt/doc/RCS/juego.c,v 1.2 2007/02/28 13:46:14 root Exp $

$

También podemos buscar identificadores dentro de un archivo, por ejemplo:

$ co ./juego.c
./RCS/juego.c,v --> ./juego.c
revisison 1.2
done
$ ident juego.c
juego.c:
$Header: /mnt/doc/RCS/juego.c,v 1.2 2007/02/28 13:46:14 root Exp $

Es posible ver que cambios se han realizado de una versión a otra, por ejemplo:

$ rlog ./juego.c
RCS file: ./RCS/juego.c,v
Working file: ./juego.c
head: 1.3
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Archivo principal del programa tirar dados
----------------------------
revision 1.3
date: 2007/02/28 14:32:09; author: root; state: Exp; lines: +2 -2
Le puse "numero de tiradas" en vez de "tiradas"
----------------------------
revision 1.2
date: 2007/02/28 13:46:14; author: root; state: Exp; lines: +3 -3
Le he agregado el Header
----------------------------
revision 1.1
date: 2007/02/28 13:36:34; author: root; state: Exp;
Initial revision

CVS

Para los que no sepan que es CVS, una pequeña introducción...

El Concurrent Versions System (CVS), también conocido como Concurrent Version System o Concurrent Versioning System, es una aplicación informática que implementa un sistema de control de versiones: mantiene el registro de todo el trabajo y los cambios en los ficheros (código fuente principalmente) que forman un proyecto (de programa) y permite que distintos desarrolladores (potencialmente situados a gran distancia) colaboren. CVS se ha hecho popular en el mundo del software libre. Sus desarrolladores difunden el sistema bajo la licencia GPL. Fragmento tomado de la Wikipedia.

Pero... Â¿porqué RCS y no CVS? o Â¿porqué CVS y no RCS? RCS es un sistema similar al CVS (Concurrent Versions System), de hecho CVS trabaja sobre RCS, con un repositorio (lugar donde se hace seguimiento de los cambios entre versiones), pero sin la parte de concurrencia. Es decir: RCS resulta conveniente cuando no hay varios desarrolladores trabajando sobre el mismo código fuente, que además pueden aplicar cambios de forma concurrente en el repositorio. Así que para pequeños proyectos con uno o más desarrolladores, pero con solo una persona encargada de aplicar los cambios, RCS es una opción a considerar.

Antes de empezar debemos tener claros ciertos conceptos:
repositorio: jerarquía de directorios alojada en el servidor que contiene diferentes módulos a disposición de los usuarios.
módulo: árbol de directorios que forma parte del repositorio; cuenta con un nombre identificador gracias al cual podremos bajárnoslo de forma selectiva.

La instalación la puedes hacer a través de apt-get, urmpi, emerge, o con el tarball. Lo más sencillo sería, si tienes Debian o un derivado, hacer:

apt-get install cvs cvs-doc cvsbook

Invocar a cvs

cvs es un programa que se invoca desde intérpretes de órdenes. según cómo sea su configuración (y estoy pensando en las diferentes formas de autenticación) lo podrás usar en procesos por lotes sin ningún problema.
Un aspecto que debes tener en cuenta (sobre todo si este es el primer documento que lees sobre cvs) es que cvs tiene parámetros para cada una de sus órdenes. para conocerlas tienes dos métodos: invocar cvs como Â«cvs helpÂ» o mirar la ayuda.

Configuración

Puedes usar varios ficheros de configuración que cvs reconocerá y usará. Los más importantes:

~/.cvsignore
    que contiene los sufijos de los ficheros que no nos interesa que cvs controle: *.tex *.aux *.dvi *.ps *.log
~/.cvsrc
    que contiene parámetros que cvs usará cada vez que se invoque:
        cvs -z 3
        update -Pd
        diff -uw

La autenticación

Al trabajar en remoto con cvs pueden elegirse varias alternativas de autenticación (es decir, de demostrar al servidor que somos quienes decimos que somos). Las que más he visto usar son vía pserver y vía ssh. Deberás elegir alguna de estas técnicas en función de tus necesidades, las ganas que tengas de complicarte la vida y, sobre todo, del grado de neurosis obsesiva por la seguridad que padezcas.

ssh

Como uno va por la vida predicando el software libre no puedo más que recomendar el uso de OpenSSH que puede encontrarse en http://www.openssh.org. Si no me equivoco, esta herramienta es compatible con la norma ssh 1.x.

Para que cvs use este modo de autenticarse se pueden usar estas variables de entorno:

export CVSROOT=":ext:USUARIO@www.vivalavirgen.com:/home/cvs"
export CVS_RSH=/usr/bin/ssh

donde USUARIO es nuestro nombre de usuario; www.vivalavirgen.com es el servidor que aloja al repositorio; /home/cvs es el directorio del servidor en el que está el repositorio; /usr/bin/ssh es la ruta completa al amigo ssh.

Ten en cuenta que, usando esta técnica, tendrás que autenticarse (es decir, suministrar su contraseña) cada vez que ejecute cvs.

pserver

Esta técnica es más de Â«andar por casaÂ». Se monta rápidamente y no necesita de programas añadidos.

export CVSROOT=":pserver:USUARIO@www.vivalavirgen.com:/home/cvs"

donde USUARIO es nuestro nombre de usuario; www.vivalavirgen.com es el servidor que aloja al repositorio; /home/cvs es el directorio del servidor en el que está el repositorio.

Si usa esta técnica, antes de poder trabajar con cvs debe autenticarse con el servidor. Eso se hace con la orden login:

$ cvs login

CVS le pedirá la contraseña del usuario que haya configurado. Si la contraseña es correcta cvs guardará la información que necesita en el fichero ~/.cvspass y no tendrá que volver a autenticarse. Si por algún motivo exotérico quisieras Â«cerrar la sesión cvsÂ» bastará con hacer:

$ cvs logout

Modo de uso

A continuación se propone una sencilla metodología de trabajo con cvs para evitar trabajos redundantes. Piénsese por ejemplo en la eliminación de erratas o errores en documentos o en código fuente.
Antes de cada sesión de trabajo es conveniente hacer Â«cvs updateÂ» para asegurarnos de que disponemos de las últimas modificaciones.
Justo al acabar cada sesión de trabajo es conveniente hacer Â«cvs ciÂ» para que todas nuestras modificaciones se propaguen en el servidor.

Bajar por primera vez el módulo

Para crear una copia de trabajo local del módulo cvs deseado debemos usar la orden co (o su equivalente checkout):

$ cd [padre-de-directorio-donde-se-alojará-el-módulo]
$ cvs co [nombre-del-módulo]

Esto creará una jerarquía de directorios donde se almacenará el módulo. Este paso sólo hay que hacerlo una vez por cada módulo. A partir de este momento no es necesario configurar las variables de entorno porque cvs sabe a qué repositorio pertenece el módulo con sólo examinar los subdirectorios CVS. No debes modificar nunca esos subdirectorios o volverás loco al pobre cvs.

Actualizar cambios

Cuando queramos actualizar la copia local del módulo con los cambios que hayan podido hacer otros usuarios y que ya han sido enviados al repositorio deberemos hacer:

$ cd [directorio-del-módulo]
$ cvs update

Observaréis que cvs informa acerca de qué está haciendo con cada fichero y para eso utiliza un código de una letra. Este es el significado:

U
    Se ha bajado un fichero completamente nuevo.
P
    Se ha bajado una modificación del fichero y ahora éste está actualizado.
A
    El fichero lo ha añadido usted pero no lo ha subido todavía al repositorio.
R
El fichero ha sido borrado (pero podría recuperarse del histórico que se almacena en el repositorio).
C
Hay un conflicto: otra persona ha modificado antes las mismas partes del fichero y no le queda más remedio que revisarlo manualmente antes de poder subir los cambios de ese fichero.
M
    Usted ha modificado el fichero pero aún no lo ha subido al repositorio.
?
CVS se ha encontrado un fichero que no tiene registrado y simplemente avisa y lo deja en paz.

Publicar nuestras modificaciones

Se usa la orden ci (o su equivalente commit):

$ cd [directorio-del-módulo]
$ cvs ci

Tras lo cual el sistema mostrará la pantalla de un editor de textos (el que tengamos configurado como nuestro favorito en las variables de entorno) para que describamos el cambio.

Resolución de conflictos

Tal cual la ONU habrá ocasiones en las que tengamos que resolver los conflictos que surjan entre diferentes versiones para que cvs continúe trabajando. Estos conflictos son normales y ocurren cuando dos o más personas modifican a la vez exactamente la mismas partes de un fichero. El procedimiento es simple:

cvs se quejará de un fichero;
editamos ese fichero;
encontraremos unas marcas del tipo
[...]
>>>>>>>>>>>>>>
taca
===========
tacataca
<<<<<<<<<<<<<<
[...]
El texto entre marcas es el que produce el conflicto. Hay que elegir qué modificación nos gusta y borramos todo lo demás.
Si no quedan conflictos volvemos a hacer el Â«ciÂ» y a ser felices.

Añadir ficheros al módulo

No olvides que cvs controlará sólo los ficheros que se le hayan indiciado expresamente. Cualquier otro fichero en el directorio cvs será ignorado.
Si quieres incluir un nuevo fichero o directorio al módulo cvs hay que seguir los siguientes pasos:

$ cd [directorio-del-módulo]
$ cvs add [fichero]

Pero si el fichero es binario hay que tener la precaución de hacer:

$ cd [directorio-del-módulo]
$ cvs add -kb [fichero]

Â¿Por qué?, se preguntará el lector más intrépido. Resulta que CVS usa varias variables (en realidad son de RCS, que funciona por debajo de CVS). Si el fichero es binario es posible que se de una combinación de bytes que coincidan con alguna de estas variables. Si así fuera, RCS/CVS modificaría el contenido y lo corrompería. También se debe a que el sistema de cálculo de diferencias que usan estos sistemas no está diseñado para trabajar con información binaria. Si se obra equivocadamente es probable que corrompamos los datos.
También quiero señalar que si bien se pueden gestionar ficheros binarios, no se hará control de versiones de los mismos. Sólo se guardará la última versión.
Tras el Â«addÂ» hay que hacer un Â«cvs ciÂ» para actualizar el servidor con los nuevos ficheros.

Eliminar ficheros del módulo cvs

Para eliminar un fichero del módulo cvs hay que hacer lo siguiente una vez borrado el fichero:

$ cd [directorio-del-módulo]
$ cvs remove [fichero]

En cambio, si queremos borrar físicamente los ficheros a la vez que los eliminamos del módulo deberemos usar:

$ cd [directorio-del-módulo]
$ cvs remove -f [fichero]

Cómo configurar un servidor y cómo subir nuevos módulos al repositorio. Si este documento es tu referencia favorita sobre cvs no merece la pena que te explique cómo se hacen estas cosas porque de todas formas no te ibas a enterar. Espabila un poco porque es bien fácil una vez que uno se ha mirado los manuales.

Si alguien con mejor corazón que yo tiene tiempo, que amplíe esta sección para beneficio de todos.

Herramientas con Interfaces gráficas para CVS

Espero que si llegas a este punto es por curiosidad o por la inercia de la lectura porque los verdaderos tecnófilos tienen que saber exactamente qué es lo que hacen en cada momento sin que ninguna clase de software intente facilitarles la vida encapsulando complejidades. Sobre todo cuando ese software ofrece interfaces gráficos.
En cualquier caso y para que nadie pueda dudar de mi profesionalidad voy a enumerar unos cuantos interfaces gráficos cvs en mayor o menor estado de desarrollo:

pharmacy
gcvs
tkcvs, para unix y windows y que además saca un bonito grafo con el historial de desarrollo.
Tortoise, para windows, integrado en el gestor de ficheros.
wincvs, para windows, como bien sugiere el nombre. He oído hablar mal de él, pero como no lo he probado no puedo asegurar nada.
cervisia, para KDE.
lincvs

Bueno, ya me aburrí. para encontrar los enlaces que faltan, la mayoría aparecerán en http://freshmeat.net y con el tiempo tal vez aparezcan nuevas herramientas.

Otros recursos cvs interesantes

La página principal que creo que ahora está en http://www.cvshome.org/.
cvsq, una utilidad para trabajar sin conexión permanente a la red: http://freshmeat.net/news/2000/07/02/962595201.html.
Enlaces a documentación y otros recursos.
cvs2cl.pl, que es una herramienta para crear ficheros Changelog al estilo GNU y que puede encontrarse en http://www.red-bean.com/cvs2cl/

Otros recursos cvs más avanzados

cvsadmin es una herramienta para administrar las cuentas de un repositorio.
cvs-nserver es una reescritura y extensión de cvs para mejorar sus capacidades en red.
cvsauth sirve para autenticar usuarios sin ejecutar en el servidor cvs como root.

<<anterior | siguiente>>
Indice

Creación de documentación para el comando man

2007-03-02T15:55:00.000-05:00

Existen diversas herramientas para la creación de páginas para el comando man. En este caso me centraré en pod2man, una aplicación muy fácil de usar y que viene en casi todas las distros. pod2man es una utilidad que viene junto al perl, por ello es muy difícil que no se encuentre en una distro; es una de las razones por la que la he escogido.

Al grano. Para crear la página de manual de un programa (el de los dados, por variar). Lo primero será editar un archivo de texto plano, para ello utilizamos vim o emacs (Â¿has utilizado nano?), que deberá tener la siguiente estructura:

=head1 NOMBRE

juego - programa para lanzar dados

=head1 SYNOPSIS

juego un_numero

=head1 DESCRIPCION

Este es un programa que sirve para lanzar dados. Â¿qué? Â¿cómo? Â¿no te gusta? Â¿te parece inútil? A mi también y no me ando quejando Â¿acaso crees que es fácil hacer ejemplos de práctica? Mejor dedicate a aprender gran-son hijo de *******. Es en serio: si estudias este tutorial te volverás un poco más inteligente, tu mente se abrirá, cada vez aprenderás más, llegará a tu escritorio una carta donde se te pide trabajar en una sofisticada empresa de software (solo porque entiendes el programa de los dados), luego harás conferencias en todos lados (y para toda clase de personas: programadores, linuxeros, adictos al juego de dados, etc.), luego te harás muy rico, tendrás sexo con las mujeres más lindas del mundo, comprarás Playboy, conquistarás el mundo... y cuando todo eso pase, te acordarás de mi, sí, ese pobre que hizo un tutorial de más de 30 páginas, con el único fin de aportar su granito de arena, y al que un dia miraste con asco, pensando que era un negligente, mediocre e ignorante, y.... eso es todo. (todo esto es para llenar más espacio en esta parte manual, pero podría facilmente suceder)

=head1 AUTOR

Cristian Castiblanco E<lt>castidiablo@gmail.comE<gt>.

=cut

Llamaremos a este archivo juego.pod. Luego utilizaremos el comando pod2man para crear la página de documentación, así:

$ pod2man --lax juego.pod > juego.1

La opción lax se utiliza para que se acepten nombres diferentes a los habituales para las secciones, pues en este caso están traducidos al espaÃ±ol. La página leída puede ser observada con el comando:

$ man -l juego.1

El único paquete necesario para la utilización de pod2man es perl. Si el programa que se quiere documentar está escrito en perl, el código pod puede estar dentro del propio programa y puede servir tanto para documentar el código fuente, como para crear la documentación adicional para man. Por otro lado, he leído en una bitácora (en barrapunto) la existencia de un programa llamado asciidoc, y según los comentarios es excelente, pero en verdad no lo he utilizado, si deseas más información acerca de éste programa no queda más que utilizar el Google.

<<anterior | siguiente>>
Indice

Anjuta, un IDE de C++ para Linux

2007-03-02T15:51:00.000-05:00

Antes que nada debemos tener claro Â¿Qué es un IDE? IDE son las siglas en inglés de Integrated Development Environment algo así como Ambiente Integrado de Desarrollo, y es un conjunto de herramientas útiles al programador colocadas en un todo para no tener que estar usando las herramientas por separado y de diferentes autores. Los componentes más comunes de un IDE son: un editor de texto, un compilador, un intérprete, un depurador y después vendrán los plugins que cada IDE tenga como característica especial.

Algunos IDE pueden tener soporte para varios lenguajes de programación y otros están especializados para un solo lenguaje. El IDE del que hablaremos es Anjuta IDE; este es un proyecto libre que busca ofrecer un IDE para C y C++, aunque también se soportan otros lenguajes como Perl. Anjuta está escrito para GTK+ y GNOME.

Muchas de las distribuciones más populares de GNU/Linux ya traen entre sus paquetes a Anjunta, y será fácil de instalar usando sus respectivas herramientas (apt-get, urmpi, emerge , e tc.) Sin embargo desde el sitio web del proyecto podemos descargar el tarball para instalarlo nosotros mismos.

Lo primero que debemos hacer una vez que lo hayamos descargado es extraer el contenido del tarball:

$ tar -xvzf anjuta-1.2.4.tar.gz

Después de esta instrucción desde la lÃnea de comandos, entraremos al directorio en donde se encuentra todo el contenido del tarball

$ cd ./anjuta-1.2.4a

Algo que siempre recomiendo en la instalación de cualquier cosa es el leer el README.TXT, esto siempre es importante en todo lo que hagamos. Bien, continuando con la instalación debemos de tipear las siguientes instrucciones desde la línea de comandos:

$ ./configure
$ make
$ make install

Ahora sí entiendes como funciona eso de make Â¿verdad? Con esto habremos terminado de construir Anjuta IDE sin importar si está o no empaquetado para nuestra distribución.

El primer contacto con Anjuta

La primera vez que iniciemos Anjuta veremos un IDE sencillo, bien ordenado y que si no supiÃ©ramos nada de software alternativo, bien podrÃa pasar por un IDE de esos comerciales. Al dar click en nuevo nos aparecerá un diálogo que nos preguntará el tipo de archivo a crear, un .c, .cpp, .pl, etc. Algo que m e llamó la atención de esta parte es que podemos activar una casilla con la cual nuestro nuevo programa ya aparecerá comentado con la leyenda de la GPL, :D asÃ desde antes de escribir el código ya nuestro programa es libre.

Anjuta tiene todo lo que podemos esperar de un herramienta que nos ayudará a programar, como es un asistente que nos guiará paso a paso en la creación de nuestros proyectos; o si ya tenemos un proyecto hecho y queremos importarlo, bueno, pues Anjunta cuenta con esta opción; y claro, ya hablando de las características del editor pues tendremos el ya muy característico resaltado de sintaxis, identado y el autocompletado de instrucciones y variables.

En pequeño ejemplo

Anjuta es tan sencillo que realmente no hay mucho que decir, pues todo no lo pone a nuestro alcance, así que probaremos nuestro ya famoso programa de lanzar dados. Como ya tenemos los archivos, lo único que tenemos que hacer es ir al menÃº Archivo y dar click en Abrir; escogemos nuestros dos programas en C++ de ejemplo juego.cpp y tirador .cpp; luego vamos al menú Build y le damos en "Compile".

Ahora ejecutemos el programa... recuerda que es necesario enviar/pasarle un argumento a nuestro programa. Anjuta nos dá la posibilidad de simplemente Ejecutar el programa o Ejecutarlo con parámetros. Para esto vamos al menú Build y le damos en â€œSet program paramsâ€, click en ejecutar y...

Esto es lo básico del Anjuta, pero el programa está lleno de opciones y herramientas... una muy buena es el permitenos trabajar con CVS.

<<anterior | Indice

Revista NEX IT

2007-02-27T16:17:00.000-05:00

Edición 1	Edición 2
Edición 3	Edición 4
Edición 5	Edición 6
Edición 7	Edición 9
Edición 10	Edición 11
Edición 12	Edición 13
Edición 14	Edición 15
Edición 16	Edición 17
Edición 18	Edición 19
Edición 20

Para más información visita la página web de la revista Nex IT.

Usando Google Docs para hacer más fácil la tarea de los bloggers...

2007-02-26T16:07:00.000-05:00

Google Docs es uno de los tantos servicios de Google, que nos permite crear y modificar documentos cómunes y hojas de cálculo. Tiene una interfaz agradable y muy intuitiva usando programación en AJAX, como ya es costumbre entre los chicos de Google. Es posible acceder a este servicio con tu usuario y password de Google (el mismo que utilizas en Gmail, por ejemplo), la URL del sitio es http://docs.google.com.

Subiendo o creando archivos...

Para subir un archivo basta con ir al panel principal (Documentos de Inicio) y hacer click en “Subir”, con lo cual nos aparecerá lo siguiente:

Click en “Examinar...”, escogemos el archivo a subir, click en “Subir archivo” y listo. También es posible subir archivos a nuestra cuenta enviandolo a un correo electrónico especial (NO el de Gmail), que se nos asigna al registrarnos a Google Docs, tal como se vé en la imagen.

Además, Google Docs soporta varios tipos de archivos, por ejemplo: Archivos HTML, Archivos de texto plano (.txt), Archivos de MS Word (.doc), Texto Enriquecido (.rtf), Archivos de OpenDocument (.odt), Archivos de StarOffice (.sxw); y en cuanto a hojas de cálculo Valores separados por comas (.csv), Archivos de MS Excel (.xls), Archivos de OpenDocument (.ods).

No creo que haya la necesidad de explicar como crear un documento nuevo ¿verdad?

Jugando con nuestros documentos...

Al igual que cualquier programa ofimático es posible hacer cualquier tipo de modificación a los archivos. Desde el uso de negrita, cursiva, subrayados, etc. pasando por fuentes, tamaños, colores, búsqueda y sustitución de texto, hasta correción ortográfica, contar palabras, y un sin número de características comúnes. También es posible editar documentos desde su código en HTML.

Además, es posible guardar el documento en diferentes formatos (.doc, .odt, .pdf, entre otros), por ejemplo:

También es posible compartir los documentos en Internet, y añadir colaboradores para el mismo. Con esta característica es posible que varias personas revisen, modifiquen y/o corrijan el documento a través de Internet; incluyendo también un sistema de versiones con el cual es posible ver y/o administrar los cambios que hagan los difirentes “colaboradores”.

Para los Bloggers también hay herramientas...

Una de las características más útiles y que más me ha gustado, es la de publicar documentos directamente a un blog. Esto es bastante útil entre usuarios que, como yo, prefieren editar sus entradas y posts estando offline, y luego, al terminar, subir los resultados.

Google Docs tiene soporte para los servicios de blog más utilizados actualmente, y el proceso para publicar entradas es bastante sencilla. Veamos un ejemplo... Editamos un archivo, lo guardamos, y luego hacemos click en la pestaña “Publicar” (arriba a la derecha), luego configuraremos la cuenta para que pueda publicar entradas en nuestro blog.

Como ves, Google Docs soporta una variedad de blogs, como: Blogger, BlogHarbor, BlogWare, LiveJournal, SquareSpace o WordPress (incluyendo blogs que tengas en un servidor propio). En este caso vamos a configurarlo para Blogger:

Como vemos es muy fácil. Basta con tipear el nombre de usuario, la contraseña, el ID del blog (o el título) y listo!!!. Después de la configuración le damos click en “Publicar en blog” y... buaaalaaaa (¿o Voilá?)!!!

2007-02-26T10:06:00.000-05:00

La importancia de la gramática...

Para reflexionar XD:

Un gerente de una compañía está intrigado con el extraño comportamiento de uno de sus empleados, por lo cual contrata un detective privado para que lo investigue. Después de un par de dias el detective va a la oficina del gerente, para informarle de los resultados que ha arrojado su investigación.

El detective dice al gerente: “Juan López sale todos los dias a medio dia, coge su coche, va a su casa, almuerza, hace el amor con su mujer, se fuma uno de sus mejores habanos, y regresa al trabajo”.

El gerente dice tranquilo: “Ahh, bueno, no hay nada de malo en eso”, entonces el detective le pide permiso al gerente para tutearlo, a lo que el gerente accede extrañado.

El detective dice al gerente: “Te lo repito, Juan López sale todos los dias a medio dia, coge tu coche, va a tu casa, almuerza, hace el amor con tu mujer, se fuma uno de tus mejores habanos, y regresa al trabajo”.

Instalación de un entorno Web: Tomcat + JSP + MySQL

2007-02-22T09:24:00.000-05:00

Este pequeño artículo pretende orientarte un poco en los pasos para hacer correr aplicaciones Web en JSP que manipulen bases de datos en MySql. Aunque está orientado a Linux los pasos son muy similares para hacerlo en MS Windows. Primero aclarar unos conceptos, como...

Aunque ya debes tener la mayoría de esos conceptos más que claros, sino no estarías leyendo por aquí. Umm, ¿en qué me quedé? ammm, ya. Lo siguiente es instalar las aplicaciones que necesitamos en el siguiente órden.

Instalar el Java 2 SDK (si usas Debian o Ubuntu esto talvez te interese), también hay algunas distros que vienen con el compilador de Java incluido (como Knoppix).
Instalar el Apache Tomcat
Instalar el MySQL (en Windows | en Linux)

Hecho esto tienes que copiar el controlador para Java de mysql que puedes encontrar en la página web de Java (te lo hago fácil, bájalo de aquí, descompríme el ZIP y te quedará el archivo de java mysql-connector-java-3.1.8-bin.jar) y cópialo en la ruta jre/lib/ext/ en mi caso lo copio en /usr/lib/j2sdk1.5-sun/jre/lib/ext/, por ej. Este es el driver que necesita JSP para accesar correctamente las clases para manipular bases de datos en el gestor MySQL.

Eso es todo... solo aclarar que, en algunos casos, sistemas operativos basados en Debian como el Ubuntu el usuario y contraseña del MySql no se encuentra en el archivo mysql.cnf sino en el archivo debian.cnf que se encuentra en el directorio /etc/mysql.

Un ejemplo simple – Accesando una base de datos MySQL con JSP
Vamos a hacer un pequeño ejemplo en el que consultaremos los datos de una tabla, no vamos a insertar, eliminar ni actualizar en el ejemplo, solo consultar, ya que el objetivo del artículo es otro (“les das la mano y te cogen todo el brazo” decía mi abuela). Lo primero es tener una base de datos base para operar sobre ella; entonces crearemos una sencilla.

Para algunos: ¿qué? ¿cómo? ¿no sabes hacer bases de datos en MySQL? Ohh, no, no nooooo, por queeeee!!! Si es tu caso existen muchos manuales en la web para hacer esto, basta con una búsqueda en el Google, de seguro encontrarás miles de manuales (no es exageración).

Pasado el susto proseguimos con la creación de la base de datos, que sería algo como esto (supongo que ya sabes como es la cosa): Pimero iniciar el MySQL, verificar las bases de datos existentes y crear la nuestra (la del ejemplo):

Ahora ingresaremos a la base de datos “ejemplo”, crearemos una tabla (“hombre”) e insertaremos datos en dicha tabla:

Listo!!! Ahora, lo que tenemos que hacer es crear nuestro programa en JSP que consulte (al menos) la base de datos...

Para algunos: Noooo!!!! No me digas que tampoco sabes programar en JSP. Pero ¿cómo? ¿en que andas pensando? ¿que los santos sudan y les da pecueca? Shiiitt, ¿porqué Dios mio? ¿porqué a mi? si mi nick no es lo que parece DIOS!!! ummmjuuuuu, calmado, tranquilo... lo mismo de siempre: Busca en el google, hay infinidad de tutoriales: leelos!!!

Pasado el segundo susto (me van a matar de un paro cardiaco) y confiando en que ya sepas lo básico de JSP proseguimos; primero crearemos un archivo llamado conexion.jsp que contendrá dos funciones, una que devuelve el usuario, y otra el password:

<%!
String usuarioMysql(){
return "debian-sys-maint";
}
String passwordMysql(){
return "i43sVHb2AAeK6SXw";
}
%>

Esto es útil, ya que en muchos casos es necesario transportar la apilación a diversas plataformas o SO, y los datos de MySQL (user y password) cambian de una a otra. Además, cuando realizamos cualquier tipo de operación a la base de datos (consultar, modificar, etc.) desde JSP, es obligatorio el uso del par usuario/password; entonces, si los datos de usuario y password cambiasen por algún motivo, tendriamos que modificar todos y cada uno de los archivos de JSP que accedan a la base de datos, una tarea muy engorrosa y difícil, por no decir peligrosa.

Para solucionar el problema utilizamos un archivo (en este caso conexión.jsp) que guarde usuario/password, y los otros archivos que necesiten dicha información lo único que tienen que hacer es invocar las funciones usuarioMysql() y passwordMyslq(); así, en caso tal que el usuario o el password cambien, solo es necesario modificar el archivo conexión.jsp. Veamos entonces el segundo archivo (listar.jsp):

<%@ page import="java.io.*,java.util.*,java.net.*,java.sql.*" %>
<%@ include file="conexion.jsp" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head><title>Ejemplo consulta JSP</title></head>
<body><center>
<%
Connection canal = null;
Statement instruccion=null;
ResultSet tabla= null;
String conexion = "jdbc:mysql://localhost/simple?user="+usuarioMysql()+"&password="+passwordMysql();
//Abrir el enlace
try{
Class.forName("com.mysql.jdbc.Driver").newInstance();
canal = DriverManager.getConnection(conexion);
instruccion = canal.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
}
catch(ClassNotFoundException e){ out.println(e);}
catch(SQLException e){ out.println(e);}
try{
tabla = instruccion.executeQuery("select cedula, nombre from hombre");
out.println("<table border=1>");
out.println("<tr><th>Cedula</th><th>Nombre</th></tr>");
while(tabla.next()){
out.println("<tr><td>"+tabla.getString(1)+"</td><td>"+tabla.getString(2)+"</td></tr>");
}
out.println("</table>");
}
catch(Exception e){ out.println(e);}
%>
</center></body>
<html>

Detallemos un poco (muy poco) el programa:

El la primera línea importamos los paquetes necesarios para realizar consultas en una base de datos en MySQL.
En la línea 2 importamos el archivo conexion.jsp que contiene las funciones usuarioMysql() y passwordMyslq(). Este es el equivalente a la función include en PHP.
La porción de código de JSP vá encerrada entre <% y %> (Esto ya lo debes saber ¿no?)
Se declaran los objetos necesarios para la conexión.
Se crea una instancia del controlador (driver) de MySQL.
Se ejecuta una sentencia SQL para la consulta.
Y mediante el uso de out.println se crea la tabla (en HTML) de los datos.

Si no te quedó claro es porque seguro no te has leído nada de JSP, en todo caso el objetivo del artículo era simplemente crear el entorno web JSP+MySQL, me he salido del tema, en fin... Copiamos estos archivos a la carpeta de apicaciones JSP del Tomcat (eso ya lo hicimos aquí, así que no es necesario detenerme a explicarlo). El servicio (daemon o demonio) de MySQL debe estar ejecutándose. Ponemos a correr el servidor tomcat, ejecutamos la aplicación y... buuuaaalaaaaaaa!!

Eso es todo, espero que les sirva. Saludetes!!!

Descargar el tutorial completo en PDF

Noticias...

2007-02-22T09:14:00.000-05:00

Reconoce el ITESZ a alumnos expertos en sistemas Java y Solares
Cambio (Michoacán) - Morelia,Michoacán,Mexico
... a alumnos destacados que recibieron su certificación que los acredita como expertos en el manejo de los sistemas operativos informáticos Java y Solares. ...

La demanda de profesionales de tecnología se duplicará este año
infoBAE profesional - Buenos Aires,Argentina
Asimismo, el estudio muestra que los mayores problemas se presentan a la hora de conseguir analistas y programadores especializados en lenguaje Java y .Net. ...
Tecnologías Java, una nueva carrera a distancia en la UTN
IS-Portal (Comunicados de prensa) - Barcelona,Spain
Solaris Express, Developer Edition, una distribución basada en OpenSolaris para desarrolladores de Java, Solaris y la Web 2.0. ...

Revistas y e-zines

2007-02-20T12:50:00.000-05:00

En esta sección me gustaría compartir con ustedes algunas revistas y eZines que he coleccionado, orientadas fundamentalmente al software libre, la informática, el hacking, etc. Dichos documentos están en PDF, y de verdad recomiendo la lectura de estas grandes fuentes de información y conocimiento. Obviamente he de incluir (en un futuro) las famosas revistas de HackXCrack, pero las que tengo son/están escaneadas, por lo cual no son de buena calidad y pesan bastante; la buena noticia es que ya casi me las consigo todas (son 30) originales, vale la pena que las tengas. En este momento están disponibles estas, espero que les sirva:

Essentia Libre: Es una revista colombiana enfocada al software libre y al open source. La recomiendo.
Prácticas de los foros de HXC: Son 45 pequeños, pero completos, documentos que explican como hacer ciertas cosillas de redes y hacking.
RevistaSL: Es una revista mexicana enfocada al software libre.
[in]secure: Esta es una excelente revista dedicada a la (in)seguridad informática [en inglés].
COMOS's: Algunos de los COMOs de los foros de HackXCrack.
Begins: Es una revista chilena en la que se habla de software libre, linux, programación, etcs.
WARE: Excelente revista de informática, lastimosamente solo sacaron 6 ediciones, ya que tuvieron problemas monetarios pero tenía contenidos muy buenos.
NEX IT: Es una revista/periódico argentino que trata diversos temas del mundo IT (Windows, Linux, seguridad informática, redes), bastante profesional. De momento hay 20 números.
Users Linux

La lista irá creciendo poco a poco (espero). Si conoces más y te gustaría compartirlas no dudes en poner un par de links o enviarmelas por correo.

Algunos de los mirrors de descarga son los originales de cada revista, es decir, son links a las repectivas webs de cada proyecto. Esto debido a que no tengo un buen hosting en donde alojar los archivos, talvez en un futuro compre uno para no tener más inconvenientes.

Prácticas Hacking [sacado de los foros de HackXCrack]

2007-02-19T14:59:00.000-05:00

Espero les sea de ayuda:

Práctica 1. Configurando esafe para autenticar sesiones	Práctica 2. Vigilancia de Pc's no custodiados con salus	Práctica 3. Video-Vigilancia con PCSpy	Práctica 4. Crear un banco de pruebas	Práctica 5. Esnifar sesiones de navegacion
Práctica 6. Ocultar la IP	Práctica 7. Enviar mail anonimo usando telnet	Práctica 8. Enviar mail anonimos mediante Phasma	Práctica 9. Repeler cartas bomba y SPAM con Email Remover	Práctica 10. Encriptar mensajes de correo con PGP
Práctica 11 Creacion de un disco duro virtual encriptado con PGP	Práctica 12. Configurar un Servidor de FTP	Práctica 13. FXP entre servidores	Práctica 14. Correos maliciosos	Práctica 15. Convertir el Serv-U en un troyano
Práctica 16. Habilitar y deshabilitar las auditorias	Práctica 17. Arrancando el Serv-U automaticamente	Práctica 18. Manipulando el Registro de Windows	Práctica 19. Empleo de RootKit NTRoot	Práctica 20. Instalacion y configuracion de ZoneAlarm
Práctica 21. Como Saltarse a ZoneAlarm y a otros	Práctica 22. Ocultacion de archivos. Joinner, Camuflages y Streaming	Práctica 23. Datos del registro y Permitir Relay de correo con Sam Spade	Práctica 24. Volcado de su Web a nuestro equipo con Teleport	Práctica 25. Barridos Ping y trazado de rutas
Práctica 26. Localizacion geogrofica con VisualRoute y Neotrace	Práctica 27. Deteccion del Sistema Operativo. Netcat, Grinder, chronicle	Práctica 28. Ocultar la IP mediante un Bouncer	Práctica 29. Enviar mail anonimos usando un FTP	Práctica 30. Tuneles y Redirectores de puertos
Práctica 31 Escaneadores y exploracian de puertos	Práctica 32. Herramientas del Sistema Operativo para obtener informacion	Práctica 33. Enumeracion de Usuarios	Práctica 34. DNS y Nslookup	Práctica 35. Enumeracio ne recursos y usuarios con SNMP
Práctica 36. Aplicaciones, Registro y otros Escaneres	Práctica 37. Esnifer y craqueo de contraseñas. CAIN	Práctica 38. Paso del hash	Práctica 39. Exploits para obtener shell de system	Práctica 40. Shell remota con psexec.exe
Práctica 41. Shell remota mediante el programador de tareas	Práctica 42. Interactividad con Iexplorer	Práctica 43. Una de Servicios....Marchando!!!!	Práctica 44. Control Remoto	Práctica 45. Borrado de huellas

Dolphin: el sustituto de Konqueror como gestor de archivos en KDE 4

2007-02-19T11:08:00.000-05:00

El gestor de archivos por defecto en KDE4 será Dolphin, en lugar del que ha venido siendo hasta ahora: Konqueror. Pero que nadie se alarme, Konqueror seguirá manteniendo todas sus funcionalidades para que los que prefieran seguir usándolo como gestor de archivos puedan seguir haciéndolo. En el commit hablan de la posibilidad de crear un dolphinpart para que la compartición de código entre ambas aplicaciones sea casi absoluta.

Más información aquí.

El cocinero que instaló Debian GNU/Linux y túvo éxito

2007-02-17T13:39:00.000-05:00

Por Fredy Rivera:

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 com partiendo 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 com partir 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 program a 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 sistem a operativo llamado SUSE que m e 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 q uieran 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 sistem a 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óxim a 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!

Revista WARE

2007-02-17T13:35:00.000-05:00

Edición 1

Edición 2

Edición 3

Edición 4

Edición 5

Edición 6

Lastimosamente solo sacaron 6 ediciones, ya que tuvieron problemas monetarios y tal; una de las cosas que más me gusta de esta revista, aparte del contenido que es muy bueno, es su diseño, que es realmente novedoso y agradable. Para más información visita la página web de esta excelente revista.

Revista SL (Software Libre)

2007-02-17T13:28:00.000-05:00

Edición 0

Edición 1

Edición 2

Edición 3

Edición 4

Edición 5

Para más información visita la PINCHE página web de esta excelente revista Mexicana.

ImageShack, hosting gratuito para tus imagenes

2007-02-17T13:16:00.000-05:00

Muchos ya conocen el servicio que ofrece ImageShack, aunque pocos los que le sacan todo el jugo. Para los que no conocen el servicio les comento que es un “hosting” para hospedar imagenes, de manera fácil y gratuita. El servicio no es nuevo, de hecho lleva bastantes años, por lo cual ha madurado mucho.

Veamos alguna de las ventajas que proporciona ImageShack (sin estar registrado):

Permite que subas imágenes en cualquier momento, aún sino eres usuario registrado; basta con entrar al sitio web, seleccionar la imágen que desees subir (ya sea de tu PC u otra imágen en internet) y hacer click en Upload.
Puedes indicar que redimensione la imágen que estás subiendo.
Después de que la imágen esté alojada, puedes te facilitan ya echos el código para que las postees en un foro, en una página o el link directo de la imágen o su thumnail.

Esto está bien si lo que deseas es subir una imágen que vas a utilizar poco o desinteresadamente, pero también es posible crearnos una cuenta mediante la cual podemos administrar nuestras imágenes, etc. En cuanto a la registración basta con registrar (valga la redundancia) nuestro correo, con lo cual nos llegará un mensaje de Bienvenida y tal (normal), y el proceso de logueo no es mediante el típico login/password, sino que (dentro de la bienvenida) te dan un link de activación que coloca unas cookies en tu navegador, por lo que de hay en adelante no se necesita logueos ni nada (desde ese navegador). Las ventajas de estar registrado son:

Obviamente tienes acceso a las imágenes que ya hayas subido anteriormente.
Si no estás en el navegador donde activaste las cuentas, puedes:

Volver a utilizar el link que te mandaron al correo, o...
Mejor aún, simplemente al momento de subir la imágen indicas el correo en la caja de texto correspondiente.

Es posible más de una imágen a la vez, mediante un sistema de créditos, por ejemplo: supongamos que queremos subir 15 imágenes; subirlas una por una resulta una tarea aburrida y lenta; ImagaShack te permite comprimir en un archivo ZIP todas las imágenes, y luego subir el ZIP; el sistema automáticamente descomprimirá el archivo y alojará las imágenes por separado en el hosting. Pero ¿que es eso de los créditos? Cuando te registran te regalan 20 creditos, retomando el ejemplo anterior, al subir las 15 imágenes con el ZIP ya habrás gastado 15 créditos, por lo que te quedan 5 (yuuuujuuu aprendí a restar). Para adquirir más créditos te toca comprarlos, aunque son muy baratos.
Hace poco han actualizado el sistema (utilizando mucho AJAX), y es mucho más agradable el manejo de nuestras imágenes. Por ejemplo:

Para subir imágenes tenemos una GUI más fácil de manejar, además de que utiliza las ya famosas etiquetas para organizar las imágenes:

Acceso más fácil a la información de cada imágen:

Podemos ver qué imágenes subimos determinado dia, con el uso de un calendario que registra nuestra actividad:

Ahora dirán algunos: “eso ya lo sabía” o cosas por el estilo; me atrevo a postear algo tan “fácil” ya que hay personas que no saben como hacer este tipo de cosas, en fin... Es un servicio que uso y recomiendo, y sí: hay otros parecidos, pero entre gustos... tú decides cual servicio utilizar.

Revista [IN]SECURE

2007-02-16T16:21:00.000-05:00

Edición 1

Edición 2

Edición 3

Edición 4

Edición 5

Edición 6

Edición 7

Edición 8

Edición 9

Esta revista lastimosamente está en inglés, pero me atrevo a ponerla ya que de verdad vale la pena leerla. Para más información visita la página web de la revista [in]secure.

Nota: Los links de descarga son los de la página oficial, ya que no tengo un buen hosting para hospedarlos; sin embargo, si por algún motivo dicha web está caida puedes pedirme por correo algún número y yo te lo enviaré.