LuAuF

Herramientas profesionales gratuitas de Microsoft para estudiantes

Luciano — Tue, 30 Jun 2009 09:00:32 +0000

Los que me conocen me escucharán hablar mal de Microsoft en varios aspectos y por publicar este artículo no significa que pierda mi postura de los mismos.

Simplemente me pareció un aporte importante para aquella comunidad que utiliza los productos de Microsoft, pero que quieren dejar de estar fuera de la ley y empezar utilizar herramientas gratuitas.

Microsoft DreamSpark es una propuesta de Microsoft, especialmente dedicada a estudiantes de nivel superior, que ofrece sus herramientas de desarrolllo y diseño a nivel profesional y sin costo alguno.

Entre las herramientas que ofrece podemos disponer de:

Microsoft SQL Server 2008 Developer Edition
Microsoft Visual Studio 2005 Professional Edition
Microsoft Visual Studio 2008 Professional Edition
Microsoft Expression Studio 1.0
Microsoft Expression Studio 2 Trial Edition (includes Web, Blend, Media, and Design)
Microsoft Windows Server 2003 R2 Standard Edition
Microsoft Windows Server 2008 Standard Edition
IT Academy Student Pass
SQL Server 2008 Express Edition
Visual Studio 2008 Express Edition
XNA Game Studio 2.0 (with 12-month Creators Club Student trial membership)
Virtual PC 2007
Visual Basic 2005 Express
Visual C++ 2005 Express
Visual C# 2005 Express
Visual Web Developer 2008 Express
Visual Basic 2008 Express
Visual C++2008 Express
Visual C# 2008 Express

Enlace: Microsoft DreamSpark

Vía: El Blog de Josep Ros

El manga de Ubuntu ¿no será demasiado?

Luciano — Sun, 28 Jun 2009 09:00:12 +0000

Se sabe que Ubuntu es popular, muy popular. Se sabe de todo el fanatismo que hay detrás de la distro y de las masas que mueve, se sabe también del merchandising que dispone, pero… un manga ¿no será demasiado?

Ubunchu, el manga de Ubuntu es producto de la iniciativa de dos miembros del Ubuntu Japanese Team y Doctormo. Siendo este último un blog que según palabras del propio autor la popularidad de su blog se vio incrementada de manera notable luego de la publicación del manga, recibiendo enlace de numerosos sitios de manga y algunos blogs de Linux.

Ubunchu ya tiene publicados dos capítulos y traducciones a varios idiomas:

Capítulo 1: Ubuntu se presenta
Capítulo 2: CLI con GNOMES

Vía: PC Tux

Monitorear las operaciones de E/S de nuestro sistema

Luciano — Fri, 26 Jun 2009 07:00:38 +0000

En los sistemas GNU/Linux tenemos procesos para monitorear los procesos (valga la redundancia), como top o htop.

Unas operaciones aveces no tenidas en cuenta, pero que puede resultar quien más ralentiza un sistema, son las operaciones de Entrada/Salida. Para monitorear las operaciones E/S en Linux podemos utilizar iotop, una especie de top pero dedicado a monitorear las operaciones IO (Input/Output).

iotop es una aplicación escrita el Python, por lo tanto requiere de 2.5 o superior y una versión del kernel superior a la 2.6.20.

iotop nos muestra una tabla similar a la que imprime un comando top, donde en la primer línea nos muestra las lecturas y escritura que se están realizando y luego un listado tabulado con el PID del proceso, la prioridad, usuario, lecturas y escrituras que está haciendo a disco, el uso de swap, el porcentaje de IO que repsenta y el nombre del proceso o comando que lo está ejecutando.

El uso de iotop, así como otros comandos de monitoreo nos permite dimensionar de forma correcta el equipo que necesitamos para correr nuestro sistema, pues al fin y al cabo, adquirir un equipo no se trata de incluir el último procesador, mucha memoria, el disco más grande, etc.

Me olvidaba, pero creo que a esta altura está demás decir que para instalar iotop puedes utilizar el gestor de paquetes de tu distribución de Linux, en mi caso como utilizo un sistema basado en debian me valgo de aptitude:

sudo aptitude install iotop

Vía: MuyLinux

Trappear Ctrl+C en bash

Luciano — Wed, 24 Jun 2009 08:00:30 +0000

En alguna ocasión, puede resultar útil trappear señales en los shell scripts. Un ejemplo clásico de señal a trapear es el famoso Ctrl+C (^C).

Trappear una señal es fácil, simplemente debemos definir una acción (o función) que se ejecutará al momento de recibir la señal, y luego definir las señales a trappear con el comando trap.

Un ejemplo sencillo:

#!/bin/bash

function trapper {
echo "Signal trapped"
}

trap trapper EXIT

while true;
do
echo "I'm alive"
sleep 1
done

Realicemos un análisis rapido. El script imprime en la salida estándar un mensaje "I'm alive" cada segundo. La ejecución no termina a menos que enviemos una señal (while true;). Al presionar Ctrl+C estamos enviando la señal de EXIT, esta señal es interceptada y dirigida la ejecución a la función trapper, esto gracias a que antes con trap definimos la acción a tomar ante la señal.

Así como trapeamos la señal EXIT, podemos trapear varias señales, puedes consultar el comando kill para consultar las distintas señales que se pueden enviar sobre un proceso en ejecución.

El uso del trapeo de señales se utiliza en los scripts para no dejar el sistema de archivos en un estado inconsistente; cosas como archivos de bloqueo, archivos temporales o archivos que has actualizado y no puedes asegurar su integridad. Ante casos como éstos, es común encontrar scripts que ante señal de EXIT (como en el ejemplo) eliminan archivos temporales o de lockeo o crean una suerte de "rollback" de las acciones ejecutadas.

Si quieres escribir un script robusto, es muy probable que requieras de trapear, por lo tanto, agéndalo.

Se acerca el “viejazo” (o segunda adolescencia) para UNIX

Luciano — Mon, 22 Jun 2009 09:00:51 +0000

Se dice que el viejazo, fenómeno ocurrido en personas del sexo masculino, también llamado segunda adolescencia se produce a las cuatro décadas. UNIX es pronto a cumplir esa edad, aproximadamente por el mes de agosto, sin embargo no creo que se trate de una segunda adolescencia, pues Unix nunca envejeció, al contrario, cada día está más joven.

La historia cuenta que allá por 1969, días después de la llegada del hombre a la luna (si es alguien cree en ese discutible suceso) un programador llamdo Ken Thomson de Bell Laboratories (subsidiaria de AT&T) aprovechando la susencia de su mujer e hijo por vacaciones (que casualidad ¿no?) escribió la primera versión de Unix en un lenguaje ensamblador.

En marzo del mismo año, los mismos laboratorios habían renunciado a seguir con un ambicioso proyecto de sistema de tiempo compartido llamado Multics (Multiplexed Information and Computer Service), del que Thomson aplicó algunos principios y como broma al proyecto anterior denominó Unics (reemplazando la primer paralabra por Thomson Uniplexed) a su proyecto.

Como AT&T Bell vió que el proyecto tenía futuro decidió apostar al proyecto e incorporar a varios programadores de los cuales se destaca Brian Kernighan. Por motivos desconocidos UNICS pasa llamarse UNIX y va tomando forma adquiriendo nuvas funcionalidades y aplicaciones como cat, chmod, chown, cp, ls, mv, who, wc, etc. Si bien el desarrollo era rápido, el principal cuello de botella estaba en Ensamblador, es así que aparece Dennis Ritchie quien con colaboración de Kernighan escribe un lenguaje de más alto nivel, añadiendo nuevas funcionalidades y más abstracción que lo que ofrecía el lenguaje B. El éxito fue rotundo y para 1973 todo UNIX ya estaba re-escrito en C.

A todo esto, el departamento de defensa estadounidense empezó a financiar su red ARPANET y con ella la pila de protocolos TCP/IP. En 1974 la Universidad de California en Berkeley recibió una copia de los fuentes de UNIX y allí el desarrolló comenzó a dispararse pues se encargaron de implementar el protocolo TCP/IP. Con esto, la conectividad en red (gran problema hasta el momento para Unix) quedó totalmente resuelto gracias a uso de sockets para las comunicaciones. Este punto fue el boom definitivo de Unix que se empieza a hacer presente en todos los servidores de red o computadoras del mundo.

Bill Joy, un recién graduado en Berkeley creó la primer versión de BSD (Berkeley Software Distribution) basada en Unix V6 de Bell Labs. Es aquí donde empieza una gran disputa legal entre Berkeley y AT&T, pues para distribuir el software (BSD) había que contar con licencias de AT&T. Pero llegó a un punto que la universisas había cambiado tantos aspectos internos del SO que la diferencia entre ambos Unix era enorme. Este conflicto duró hasta 1994, cuando Novell compró en 1992 los derechos del Unix AT&T y acordó con la universidad que consistía en eliminar de BSD todo el código residual del Unix de AT&T.

En 1982 Bill Joy fue cofundador de Sun Microsystems, empresa que se basó en Sun OS para la venta de estaciones de trabajo y servidores. En 1983 aparece la primera versión de Unix System V, el cual sería base para los sistemas AIX de IBM y HP-UX de Heweltt Packard.

En medio de la batalla legal (década del 80), Bill Gates empieza a comercializar MS-DOS, un sistema mucho más pobre que Unix, pero con la particularidad en que podía correr en cualquier computadora personal (PC), de ahí nace la historia del imperio de Microsoft, del cual no hablaremos en esta publicación.

También, a finales de esa década un estudiante finlandés llamado Linus Torvalds decide crear su propio SO basado en Minix (SO creado como recurso pedagógico por el profesor Andrew Tanenbamum). Apenas Linus tiene un prototipo funcional escribe un mensaje en Usenet y así empezaba la histora de Linux)

Volviendo el tiempo atrás, en 1983 Richard Stallman se desvincula del MIT y comienza un movimiento que se transformó en marco de referencia moral, político y legal, el proyecto GNU. No solo a filosofar se dedicaba la comunidad GNU, al contrario, escribía cientos y cientos de aplicaciones (todas de ellas libres). GNU se tardó en escribir su SO (GNU Hurd), más que nada porque fue dejado para lo último dadas las ambiciones del proyecto que proponía una arquitectura microkernel por sobre las clásicas monolíticas.

El retraso de Hurd, la llegada de Linux y el montón de aplicaciones escritas por GNU llevó a una aparición casi anárquica GNU/Linux, que no era otra cosa que el kernel escrito por Linux Torvalds acompañado por un sin-numero de aplicaciones GNU. La popularidad de GNU desde entonces provocó en cierta medida el decrecimiento de la cuota de mercado de Unix, y a la vez llevó un "Clon de Unix" a los escritorios de las computadoras personales, hasta entonces monopolizado por empresas de software propietario.

Como bonus a la impresionante historia que acabamos de leer, le agregamos a los timelines publicados hace bastante (propiamente al timeline de UNIX) el siguiente diagrama (algo más simplificado) pero con el interesante agregado del tipo de distribución de su código fuente:

Open Source
Mixed/Shared Source
Closed Source

Finalmente, una versión muy simplificada del mismo arbol de genealógico:

Vía: MuyLinux

Eliminar grub o cualquier otro gestor de booteo desde Windows

Luciano — Sat, 20 Jun 2009 09:00:42 +0000

Si has instalado Linux y decides formatear la partición del mismo y volver a utilizar Windows, aparte de que no sabes lo que te pierdes, te encontrarás con el problema de que formatear o eliminar una partición no implica eliminar también el gestor de booteo, que puede ser por ejemplo: grub.

Recuerdo hace más de 10 años cuando instalé una de las primeras versiones de Red Hat y siendo por entonces más inocente e ignorante, que ahora, quise volver a mi Windows 98. Luego de formatear la partición de Linux, LILO seguía allí (para los desprevenidos LILO es otro gestor de booteo). Gracias a dicha experiencia conocí el significado del Master Boot Record (esos primeros 512 bytes del disco que se utilizan como sector de arranque).

Para eliminar GRUB o LILO de tu sector de arranque debes iniciar con un CD de Windows Vista o XP o un diquette de arranque de Windows 98 y desde una consola de modo de recuperación (para las dos primeras versiones mencionadas) ejecutar los siguientes comandos:

En Windows XP, FIXMBR
En Windows Vista, BOOTREC /FIXMBR
En Windows 98, FDISK /MBR

Con cualquiera de estos comandos repararemos el MBR ¿es eso lo que querías? ¿no? ¿estás seguro de la decisión que tomaste?

Vía: Durmiendo afuera

Desinstalar MySQL de Linux

Luciano — Thu, 18 Jun 2009 09:00:53 +0000

Hace un tiempo habíamos instalado en Ubuntu la última versión estable de MySQL, MySQL 5.1. La instalación había sido manual (no utilizamos ningún tipo de gestor de paquetes, solo descargamos los binarios en un tar.gz) y seguimos los pasos de instalación para cualquier sistema operativo UNIX compatible.

Hoy haremos el camino inverso, es decir, desinstalaremos la base de datos y como suele ocurrir, desarmar es mucho más fácil que armar, y como verán aquí, la desinstalación no escapa de la regla.

Paso número uno, detenemos el motor de base de datos:

(sudo) /etc/init.d/mysql stop

A continuación borramos el script del init.d:

(sudo) rm /etc/init.d/mysql

Y quitamos el servicio:

(sudo) chkconfig --del mysql

Si no posees chkconfig, puedes descargarl:

(sudo) apt-get install chkconfig

O bien puedes quitarlo desde la interfaz gráfica en Sistema Administración Servicios:

A continuación, eliminamos a la fuerza el directorio de MySQL:

(sudo)rm -fr /usr/local/mysql

Puede que el anterior no haya sido otra cosa que un link al directorio mysql-version, por lo tanto en ese caso me aseguro de eliminar el directorio hacia el cual apuntaba:

(sudo) rm -r mysql-5.1.31-linux-i686-glibc23

Ya terminando quitamos el grupo mysql del archivo /etc/group y finalmente borramos el usuario:

(sudo) deluser mysql

Y eso fue todo, facil ¿no?

Queda pendiente la pregunta ahora... ¿por que desinstalamos MySQL?

Clase de Logs para PHP

Luciano — Tue, 16 Jun 2009 09:30:38 +0000

Por más entorno de debug que exista, los archivos de log son fundamentales para tracear el comportamiento de cualquier aplicación. Una aplicación web escrita en PHP no se escapa de este requerimiento tampoco.

Por tal motivo, navegando, encontré una sencilla clase para generar archivos de log. Y como siempre se necesita tener a mano código como tal, no viene mal su publicación.

El código de la clase es pequeño y sencillo, muestra por cada línea la hora y fecha en la que se escribió, así como arrays formateados. Algunas mejoras que se le pueden realizar, pero que no se escriben para no manchar el código original del autor son:

Especificar el nombre del archivo de log en el constructor o bien formarlo con el nombre del archivo o según el gusto de cada uno. Simplemente, es evitar el cableado del mismo (hoy en día, protected $_fileName = 'myLogger.log';)
Crear archivos de logs por año y mes, o por año mes y día, esto con el único objetivo de no disponer de un único archivo enorme que con el paso del tiempo no pare de crecer y crecer.

Ahora si, el código y luego un pequeño ejemplo de su utilización:

/**
   * myLogger
   * @author Edder Rojas Douglas
   * @version 0.2
   */

class myLogger {
protected $_fileName = 'myLogger.log';

/**
* @param string $path can be a directory o a file path
*/
public function __construct($path) {
if (empty($path)){
Throw new Exception("Path must be filled");
}
if (!file_exists($path)) {
Throw new Exception("The Path doesn't exists.");
}
if (!is_writeable($path)) {
Throw new Exception("You can write on the give path");
}
$this->_path = $this->_parsePath($path);
}

/**
   * Validate the path the add the filename to the path
   * @param String $path
   * @return String
   */
protected function _parsePath($path) {
$strLenght = strlen($path);
   $lastChar = substr($path, $strLenght - 1, $strLenght);
$path = $lastChar != "/" ? $path . "/" : $path;

   if ( is_dir($path) ) {
   return $path . $this->_fileName;
   } else {
   return $path;
   }
}

/**
   * Will save the path on the give path
   * @param String $line
   */
protected function _save($line) {
$fhandle = fopen ($this->_path, "a+");
f write($fhandle, $line);
fclose($fhandle);
}

/**
   * main function to add lines to the logging file
   * @param String $line
   */
public function addLine($line){
$line = is_array($line) ? print_r($line, true) : $line;
$line = date("d-m-Y h:i:s") . ": $line\n";
$this->_save($line);
}
}

require_once('myLogger.php');

$log = new myLogger(dirname(__FILE__) . "/log");
$log->addLine(array("testing", "my", 'data'));

Vía: Pain Dev

Obtener una columna con el número de fila en MySQL

Luciano — Sun, 14 Jun 2009 09:01:36 +0000

Más de una vez tuve la necesidad de en una consulta enumerar las filas de la misma, por medio de una columna calculada auto incremental ¿se entiende cual era me requerimiento?

Explicándolo de nuevo, mi necesidad era de contar con una nueva columna que sea un número auto incremental y que represente el número de fila. Según el artículo original esto se puede hacer en Oracle a través de la variable rownum (no doy fe de ello pues no conozco).

Bien, en esta publicación disponemos de la solución.

Veamos un ejemplo: tengo la siguiente tabla con nombres de ciudades ordenadas alfabéticamente:

mysql> SELECT id,name FROM City ORDER BY name ASC LIMIT 15;
+------+----------------------+
| id   | name                 |
+------+----------------------+
| 670 | A Coruña (La Coruña) |
| 3097 | Aachen               |
| 3318 | Aalborg              |
| 2760 | Aba                  |
| 1404 | Abadan               |
| 395 | Abaetetuba           |
| 3683 | Abakan               |
| 1849 | Abbotsford           |
| 2747 | Abeokuta             |
| 478 | Aberdeen             |
| 3191 | Abha                 |
| 2812 | Abidjan              |
| 1703 | Abiko                |
| 3989 | Abilene              |
| 1309 | Abohar               |
+------+----------------------+
15 rows in set (0.00 sec)

El código a continuación utiliza una variable @rownum que inicializa como argumento del FROM y se evita de declarar la variable previamente con SET @rownum: = 0;

El resultado es el que veremos abajo, sencillo y sorprendente:

mysql> SELECT @rownum:=@rownum+1 'row number',name
FROM City C , (SELECT @rownum:=0) R
ORDER BY name ASC LIMIT 15;
+------------+----------------------+
| row number | name                 |
+------------+----------------------+
|          1 | A Coruña (La Coruña) |
|          2 | Aachen               |
|          3 | Aalborg              |
|          4 | Aba                  |
|          5 | Abadan               |
|          6 | Abaetetuba           |
|          7 | Abakan               |
|          8 | Abbotsford           |
|          9 | Abeokuta             |
|         10 | Aberdeen             |
|         11 | Abha                 |
|         12 | Abidjan              |
|         13 | Abiko                |
|         14 | Abilene              |
|         15 | Abohar               |
+------------+----------------------+
15 rows in set (0.01 sec)

Vía: The road to using MySQL

Declaración de variables en Bash

Luciano — Fri, 12 Jun 2009 09:00:38 +0000

No suele ser costumbre utilizar la instrucción declare en Bash, de echo, hasta algunos quizás no la conozcan. Lo cierto es que Bash, al no ser un lenguaje fuertemente tipado y no requerir la declaración explícita de variables, nos permite prescindir de su utilización.

No obstante esto, si declaramos las variables podemos lograr algunos beneficios para casos puntuales, hasta incluso evitar errores de ejecución.

A continuación veremos algunos ejemplos para saber de que estamos hablando con esto de declarar las variables en Bash.

En el primer ejemplo veremos como forzar a una variable para que sea de lectura, por lo tanto invariable:

declare -r variable

Así, un ejemplo como el siguiente:#!/bin/bash

v=6
declare -r v
echo $v
a=0
echo $v

Devolvería:

6
line 6: v: variable de solo lectura

Para tipar datos, por ejemplo, declarar una variable como numérica entera, utilizamos:
declare -i variable

Así:

#!/bin/bash

declare -i n
n=30
echo $a
a=veinte
echo $a

Devolvería:

30
0

La instrucción declare tiene un alcance mucho mayor, por ejemplo con el argumento -a se pueden declarar arrays, con -f se pueden crear funciones, con -x se pueden exportar variables de entorno, etc. Por lo pronto, el objetivo está cumplido: saber que existe.

Vía: Noticias Interesantes de Linux