Funciones con nombre y funciones anónimas

En todos los lenguajes se pueden declarar funciones con nombre, en javascript esto es tan simple como hacer:
function mi_funcion(parametros) { }
Esto crea una función de nombre mi_funcion, que luego puede llamarse con los parámetros adecuados.

Algunos lenguajes, además, permiten declarar funciones anónimas: funciones que no tienen un nombre y que sirven para esas ocasiones en las que no se quiere crear una función para usarla solamente una vez. En javascript una situación como esta puede ser crear una función que responda a un evento:
window.onload = function() { }
El código anterior crea una función sin nombre que se asigna al objeto onload, y que puede ejecutarse luego haciendo una llamada a window.onload()

Métodos de objetos

Las funciones anónimas se usan también para agregar métodos a objetos, de hecho es la única forma de hacerlo ya que Javascript no posee una construcción del lenguaje para crear clases.
var miobjeto = { un_metodo : function(parametros) { } }
En este caso miobjeto posee un método un_metodo, que al llamarse como miobjeto.un_metodo(parametros) ejecuta la función anónima. Esto es posible gracias a que en Javascript las variables son un tipo de dato de primera clase

Tipo de dato de primera clase

Se puede encontrar una descripción en Wikipedia de lo que significa ser un tipo de dato de primera clase, pero puesto en términos sencillos quiere decir que las funciones son datos como cualquier otro y que pueden por tanto asignarse, crearse, pasarse como parámetro y manipularse casi de cualquier forma. Así, en Javascript suelen pasarse objetos de función a algunas construcciones comunes del lenguaje, por ejemplo:
function mi_funcion() { /* código */ } setTimeout(mi_funcion, 1000); setInterval(mi_funcion, 10); algun_elemento.onclick = mi_funcion;

No creo que sea algo especialmente útil, pero aquí está (y aunque no sea útil lo seguiré actualizando ): http://codiguero.alwaysdata.net

Exponer las diferencias entre Java y Javascript se ha hecho muchas veces antes, pero tengo la sensación de que la mayoría de las veces que se escribió sobre el tema se hizo siendo Javascript un lenguaje despreciado y considerado casi un juguetito de las páginas web. Javascript es mucho más que un Java básico y con algunas cosas raras, e intentaré hacer valer eso en este artículo.

Historia

Dejaré que Wikipedia mencione los detalles sobre la historia del lenguaje. Lo principal en esta historia es que el lenguaje que hoy conocemos como Javascript comenzó su vida llamándose LiveScript: el cambio de nombre fue únicamente (según algunos) para aprovechar la publicidad que se hacía en la época a Java y el impulso comercial que éste estaba teniendo.

Ejecución

Partiendo en ambos lenguajes de un código fuente válido, el proceso que sigue un programa en Java es bastante diferente al que sigue un programa en Javascript.

Java

Un programa Java se compila, generando un archivo .class por cada clase o un JAR que incluye todas las clases.
Es la JVM (Máquina Virtual de Java) la que luego ejecuta el programa.

Javascript (en un navegador)

El código fuente Javascript se incluye en la página HTML mediante una etiqueta <script> o <link> en el caso de un archivo externo. El navegador interpreta el código y lo ejecuta en un entorno restringido a la página desde la cual es vinculado.

Sintaxis

Tanto Java como Javascript utilizan una sintaxis basada en la de C.
Se podría decir que Java se parece más a C++, mientras que Javascript se parece más a C.

Tipos de datos

Java incluye los tipos de datos básicos integer (y derivados), String, boolean, float y double. Además, cada clase es un tipo de dato con el que podemos crear variables. Una variable de un tipo no puede redefinirse como de otro (a menos que otro sea superclase de uno), y se aplican comprobaciones estrictas de tipos. A esto se le llama tipado estático.

Javascript solamente posee los tipos de datos number, object, string, function. Las variables se definen sin tipo, serán del tipo que sea aquello que se les está asignando. A una variable definida de cierto tipo se le puede asignar un valor de otro tipo (por ejemplo, a una variable entera puede asignársele una cadena), y el tipo de dato de la variable cambia. A esto se le llama tipado dinámico.
Veamos un par de ejemplos para ver la diferencia. Primero, código Java:
String variable = "Hola"; <-- variable se declara de tipo String variable = 1; <-- dará un error de compilación, no se puede asignar un entero.
Y ahora un código equivalente en Javascript:
var variable = "Hola"; <-- variable se declara sin tipo. Como se le asigna una cadena, tendrá el tipo String variable = 1; <-- variable es ahora de tipo entero. No hay errores de ningún tipo :-D

Ámbito de las variables

Java, al igual que la mayoría de los lenguajes basados en C, tiene variables de bloque. Es decir, que una variable definida en un bloque de código (delimitado por las llaves { y }) existirá solamente dentro de ese bloque. En caso de producirse ambigüedad (una variable local al bloque se llama igual que una variable externa) tiene prioridad el espacio de nombres local.

En Javascript, por otra parte, solamente las funciones generan su propio espacio de nombres. Los bloques de código utilizan las variables definidas fuera, y si definen alguna variable ésta no desaparecerá cuando el programa salga del bloque, sino que seguirá definida en el espacio de nombres global (o de la función en la que esté el bloque).
Esto es algo bastante molesto en realidad, ya que puede fácilmente generar conflictos y es una de las principales razones (por si no hubiera ya suficientes) para evitar las variables globales.

Funcional

En java las funciones NO son un tipo de datos. En Javascript sí: una función es una variable como cualquier otra, que se puede pasar como parámetro a otra función o asignar a una variable. Incluso se pueden declarar funciones anónimas para utilizarlas una sola vez y que no ocupen el espacio de nombres. Se dice que una función es un tipo de dato de primera clase. Esto, junto con otras características, hacen que javascript pueda considerarse un lenguaje funcional, y, en palabras del experto Douglas Crockford, el primer lenguaje lambda en llegar a utilizarse masivamente. (donde lambda proviene del cálculo lambda, y es otro nombre para una función anónima.)

Orientación a Objetos

Java es orientado a objetos, como todos sabemos, y utiliza una orientación a objetos clásica, es decir, basada en clases. Los objetos son ejemplares de una clase (disculpen pero detesto utilizar instancia como traducción de instance), y la herencia se da entre clases.

Javascript es también orientado a objetos, pero no usa clases, aunque hay formas de simularlas y se utiliza algo similar a una clase al crear un objeto de tipo Date.
En Javascript la herencia se da directamente entre objetos, mediante prototipos. Todo objeto contiene un atributo oculto que lo vincula a su objeto padre, formando una cadena hasta el objeto padre Object (que en los navegadores es window).

Un objeto hereda todos los métodos y atributos de su objeto padre, y si al objeto padre se le agrega un método o atributo, los objetos hijos podrán ver inmediatamente el nuevo miembro añadido. Todo objeto contiene un atributo prototype al que se puede agregar miembros (atributos o métodos) para que todos los objetos hijos puedan verlos. Por ejemplo, si agrega un método metodo a String.prototype, todas las cadenas contendrán el método.

Conclusión

Espero que este repaso por algunas de las principales diferencias entre Java y Javascript sirva de algo, con un poco de suerte estaré ayudando a que ya nadie piense en Javascript como un hermanito menor de Java. Para aquellos que quieran profundizar en el lenguaje, recomiendo los videos disponibles en el YUI Theater y el libro Javascript: The Good Parts de Douglas Crockford.

Slackware es la distribución de GNU/Linux más antigua entre las que siguen desarrollándose. Se caracteriza por su fama de complicada, sin embargo una vez que el sistema está configurado el mantenimiento necesario es mínimo, y resulta tan sencilla de manejar como cualquier otra distribución. Lo único que el sistema pide a cambio de su estabilidad y facilidad de mantenimiento es algo de tiempo leyendo manuales y ayudas para comprender lo que sucede y por qué. La instalación, configuración y uso de este sistema es probablemente la mejor forma de aprender a manejar un sistema Unix.

Queda claro que le tengo un aprecio bastante grande, sin embargo soy capaz de reconocer que, como todo, esta distribución no es perfecta y tiene sus problemas. Y para solucionar los problemas suele requerirse un conocimiento de lo que se hace. Es por eso que quiero compartir mi experiencia instalando Slackware 13.0 en mi computadora Dell Vostro 1000.

Instalación

La instalación en sí no es un problema, recomiendo esta guía de instalación para aquellos que no hayan realizado este proceso antes. La guía es para la distribución ZenWalk, pero el proceso es casi el mismo ya que ZenWalk es una de las tantas distribuciones derivadas de Slackware.

Un punto a recordar es que, una vez en el programa de instalación, debe iniciarse el proceso eligiendo la opción ADDSWAP en el menú, o TARGET. Estos pasos deben hacerse primero ya que son los que preparan el disco en el que se instalará, si no se hacen primero siempre se llega a un punto en la instalación en el que se debe iniciar todo el proceso de nuevo.
Y esto siempre requiere salir del programa de instalación y abrirlo de nuevo, ya que la autodetección del disco CD/DVD de instalación funciona solamente la primera vez que se hace.

De todas formas, la instalación con las opciones por defecto (full install, instalar todos los paquetes disponibles) puede iniciarse en menos de 5 minutos y terminarse en más o menos media hora.

Al terminar la copia de archivos se hacen algunos pasos para la configuración inicial del sistema, principalmente lo que respecta a la ubicación geográfica, la configuración de red y la instalación del gestor de arranque (LILO). Una vez finalizados estos pasos, el programa de instalación se cierra y se nos indica que debemos reiniciar el sistema.

Configuración inicial

Al arrancar el sistema, a diferencia de lo que sucede con otras distribuciones, el entorno gráfico no se inicia por defecto. Se nos presenta una pantalla de inicio de sesión en modo texto, en la que deberemos entrar como el usuario root y con la contraseña correspondiente (que habremos indicado en uno de los últimos pasos de la instalación).

Una vez dentro, hay varias tareas a realizar.

Arrancar por defecto el entorno gráfico

Esto se hace editando el archivo /etc/inittab y cambiando el nivel de ejecución predeterminado. Lo haremos con vim
root@alvaro:/# vim /etc/inittab
Una vez que se abra el archivo, hay que ir a la línea que contiene
# Default runlevel. (Do not set to 0 or 6) id:3:initdefault:

vim no se parece en nada a los editores normales, por lo que para quien lo usa por primera vez puede resultar bastante extraño. La forma más sencilla de editar lo necesario y salir es llevar el cursor hacia el 3 en la línea mencionada antes, y presionar la siguiente secuencia de teclas:

• r : Pondrá el editor en el modo adecuado para reemplazar un caracter
• 4 : escribirá un 4, reemplazando al 3
• :wq : este comando guarda el archivo y sale de vim

Con esto, se indica que el nivel de ejecución por defecto debe ser el nivel 4. Normalmente cualquier documentación de GNU/Linux que se encuentre indica que el nivel 4 no se utiliza, y además casi todas las demás distribuciones utilizan el nivel 5 para el modo gráfico. En esto Slackware es diferente, en tanto que utiliza el nivel 4 para el modo gráfico y no utiliza el nivel 5.

Crear un usuario sin privilegios

La forma usual de utilizar el sistema es como usuario sin privilegios. Esto es, sin permiso para instalar programas o modificar el sistema, únicamente se tiene permiso para hacer modificaciones en la carpeta asignada al usuario. Este modo es ideal por la seguridad y para evitar errores fatales, que casi todos hemos cometido alguna vez. Añadiremos un usuario, entonces, con el comando adduser y escribiendo la información que el comando solicita.

Para que este usuario sea usable, es necesario añadirlo a varios grupos: audio (para que pueda utilizar la tarjeta de sonido), cdrom, disk, plugdev (para que pueda utilizar dispositivos extraíbles), y video. Esto se puede hacer facilmente; en uno de los pasos adduser muestra la siguiente línea:
Additional groups (comma separated) []:
Si se presiona la flecha hacia arriba, se obtiene una lista de los grupos necesarios.

Utilizar el kernel generic en lugar de huge

Para la instalación, y por defecto en la instalación completa, Slackware instala un núcleo Linux que tiene compilado casi todos los controladores disponibles. Esto implica que el núcleo por defecto es bastante grande e ineficiente, aunque en una instalación funciona bien. Para el uso diario es mejor cambiar a un núcleo que incluya solamente lo mínimo, y en el que los controladores estén incluidos en forma de módulos (de tal forma que solamente se cargarán aquellos que sean necesarios).
Este cambio requiere de varias modificaciones, que quizás sea mejor hacer desde el entorno gráfico (se requiere edición de archivos, y es más fácil usar kwrite que vim.) Por lo que reiniciar en este momento e iniciar sesión como root en el entorno gráfico puede ser la mejor idea.

Vincular al kernel correcto

Desde la consola, el siguiente comando
cd /boot ; ls -l
Debería mostrar algo como esto (eliminé algunas líneas innecesarias):
lrwxrwxrwx 1 root root 35 2008-12-18 00:49 System.map -> System.map-huge-smp-2.6.29.6-smp -rw-r--r-- 1 root root 965704 2008-11-21 02:20 System.map-generic-smp-2.6.29.6-smp lrwxrwxrwx 1 root root 32 2008-12-18 00:49 vmlinuz -> vmlinuz-huge-smp-2.6.29.6-smp -rw-r--r-- 1 root root 2347888 2008-11-21 02:20 vmlinuz-generic-smp-2.6.29.6-smp

Los archivos System.map y vmlinuz son enlaces que apuntan a las versiones huge del núcleo (esto puede verse indicado por las flechas -> junto al nombre del archivo). Debemos vincularlas a las versiones generic. Para esto, se utilizan los siguientes comandos:
rm System.map vmlinuz ln -s vmlinuz-generic-smp-2.6.27.7-smp vmlinuz ln -s System.map-generic-smp-2.6.27.7-smp System.map
Obviamente conviene hacer uso del autocompletado en bash, para no tener que recordar todo el nombre del archivo (presionar tecla tabulador).

El siguiente paso es crear el archivo initrd correspondiente. Dado que el núcleo genérico no tiene los controladores en el núcleo mismo sino como módulos, es necesario brindarle algunos controladores iniciales para que pueda encontrar el disco duro, leerlo, y cargar el resto de los módulos que necesita. Estos controladores iniciales se guardan en el archivo initrd.
Las instrucciones necesarias para crear este archivo están en el archivo README.initrd dentro de la carpeta /boot. Básicamente, para un sistema cuya partición principal es de tipo ext3, y está en /dev/sda1 (la primera partición primaria del primer disco SATA), el comando necesario es
mkinitrd -c -k 2.6.27.7-smp -m mbcache:jbd:ext3 -f ext3 -r /dev/sda1
(dentro de la carpeta /boot)
El último paso ahora es configurar LILO para que cargue este archivo initrd. Habrá que editar el archivo /etc/lilo.conf, buscar la sección correspondiente y agregar una línea al bloque
# Linux bootable partition config begins image = /boot/vmlinuz root = /dev/sda1 label = Linux read-only # Linux bootable partition config ends

que deberá quedar como
# Linux bootable partition config begins initrd = /boot/initrd.gz image = /boot/vmlinuz root = /dev/sda1 label = Linux read-only # Linux bootable partition config ends

Ya que estamos editando el archivo lilo.conf, conviene también editar el tiempo que se espera antes de arrancar el sistema, en la pantalla de selección de SO. Por defecto este tiempo es 2 minutos, recomiendo cambiarlo a un tiempo que sea corto pero permita interrumpir el proceso en caso de ser necesario (por ejemplo, medio segundo)
Habrá que ir hacia el principio del archivo lilo.conf y cambiar:
# This is given in tenths of a second, so 600 for every minute: timeout = 1200
por
# This is given in tenths of a second, so 600 for every minute: timeout = 50

Una vez realizados estos cambios, hay que re-instalar LILO. Este proceso es simplemente ejecutar el comando lilo en la terminal. Recomiendo ejecutar primero lilo -t (hacer una simulación de la instalación) y luego, si no hay errores (puede haber advertencias), ejecutar lilo.

Ahora, reiniciar el sistema nuevamente para cargar el núcleo genérico.

Configuración de una computadora portátil

Si tienes una computadora de escritorio, no se requieren más detalles de configuración, todo debería haber sido reconocido y autoconfigurado. El resto será cuestión de configurar los detalles del entorno gráfico. Pero si como yo tienes una computadora portátil, habrá otros detalles a configurar.

Red inalámbrica

Es muy probable que el dispositivo de red inalámbrica no tenga controladores para Linux. En este caso habrá que apelar a ndiswrapper, un programa que es capaz de utilizar los controladores de Windows que estos dispositivos incluyen. ndiswrapper no está incluido en la distribución de Slackware, pero puede conseguirse sin dificultad en SlackBuilds.org.
También se pueden encontrar allí otros controladores nativos para Linux, por ejemplo el controlador para las tarjetas Broadcom.

Vale la pena notar, sin embargo, que ndiswrapper no puede funcionar correctamente en un sistema de 64bit, no es capaz de cargar un controlador de 32bit de Windows en un sistema de 64bit. Así que, aún si tu equipo lo admite, asegúrate de tener los controladores necesarios antes de instalar Slackware64.

Para el control de la red inalámbrica Slackware incluye el programa wicd en la carpeta /extra. Bastará entonces con instalar el paquete desde esa carpeta. Algo importante a recordar es que, para que wicd funcione correctamente, es necesario darle permisos de ejecución al archivo /etc/rc.d/rc.wicd, y remover la configuración que se encuentra en el archivo /etc/rc.d/rc.inet1.conf. Para lograr esto simplemente se agrega una almohadilla # a toda línea de este archivo que no comience con una.
Si todo va bien entonces, al reiniciar habrá un ícono de wicd al lado del reloj, pronto para conectarse a alguna de las redes detectadas.

Synaptics, el controlador para el touchpad

El controlador synaptics viene incluido en Slackware, y el nuevo X.Org incluido en Slackware 13 lo carga correctamente sin que haya que configurar nada. Pero por defecto desactiva funciones como el hacer clic tocando la superficie del touchpad.
Para corregir este comportamiento, se pueden seguir dos caminos. El primero es editar el archivo xorg.conf, como se ha hecho toda la vida. El segundo es modificar la configuración de HAL, lo cual es más acorde a la nueva forma de funcionar de X.Org.

El segundo camino es algo más complicado que el primero, pero requiere conocer menos datos. Si se opta por modificar xorg.conf deben conocerse entre otras cosas el nombre de dispositivo y el protocolo a usar. Sin embargo, modificando la configuración de HAL se indica al sistema qué opciones dar por defecto a un dispositivo que use el controlador synaptics.

En mi caso habilité el botón primario (izquierdo) al tocar con el dedo la superficie del touchpad, el secundario (derecho) en la esquina superior derecha, y el botón central en la esquina inferior derecha.
También habilité el desplazamiento (scroll) horizontal y vertical deslizando el dedo sobre los bordes inferior y derecho respectivamente.
El archivo completo está aquí. Las opciones posibles se detallan en la página del manual de synaptics.
Este archivo debe copiarse a la carpeta /etc/hal/fdi/policy

Configuración de ahorro de energía

En KDE4, el Gestor de Energía Guidance y el módulo de Gestión de Energía en Preferencias del Sistema pueden configurar sin problemas casi todos los aspectos de ahorro de energía, excepto por un detalle: qué se hace cuando se presiona el botón de encendido/apagado.
En esta página se explica cómo se debe configurar esto, el artículo es viejo y la mayor parte de lo que se explica ya no es necesario (gracias a la combinación Guidance/Preferencias del sistema mencionada antes)
Los pasos para que al presionar el botón la computadora hiberne en vez de apagarse son los siguientes:

1. Cambiar a la carpeta /etc/acpi
2. Dejar en esta carpeta únicamente el archivo acpi_handler.sh y crear las carpetas events and actions en caso de ser necesario.
4. Crear un archivo /etc/acpi/actions/pwrbtn.sh con permisos de ejecución, y con el siguiente contenido:
   #!/bin/sh pm-hibernate
5. Crear un archivo /etc/acpi/events/pwrbtn con el siguiente contenido:
   event=button[ /]power action=/etc/acpi/actions/pwrbtn.sh

Listo, al presionar el botón de encendido la computadora hibernará en vez de apagarse. ¿Pero cómo restaurar?
Lo que hace la hibernación es mover el contenido de la memoria RAM y de algunas otras cosillas a la partición swap. Para poder restaurar el sistema es necesario indicarle al núcleo la partición de swap.
Hay que editar el archivo lilo.conf de nuevo, buscar la sección de Linux y añadirle la siguiente línea:
append = "resume=/dev/sda2"
(donde /dev/sda2 es la partición de swap).
Para finalizar, hay que volver a ejecutar el comando lilo (como antes, primero lilo -t para asegurarse de que todo es correcto, luego lilo para hacer la instalación). Con esto, si la máquina fue hibernada, el núcleo restaurará el estado. En caso de que la máquina haya sido apagada, se hará un arranque normal. En mi caso tengo configuradas dos secciones idénticas, una con el resume y otra sin él, simplemente para hacer pruebas de vez en cuando.

Pasos siguientes

Instalación de programas

Slackware no tiene repositorios de paquetes, todos los paquetes oficiales están en el DVD de instalación. Para instalar programas externos se recomienda utilizar SlackBuilds, que son scripts que automatizan la generación de paquetes a partir de archivos de código fuente. El repositorio más grande de SlackBuilds es slackbuilds.org, y la forma más sencilla de utilizar ese repositorio es a través de una herramienta llamada sbopkg.
La mayor parte de los programas tienen su SlackBuild, pero no todos. Para estos últimos lo mejor es descargar el código fuente y crear un paquete con src2pkg. En la mayoría de los casos la compilación será exitosa. Si no lo es, no queda otra opción más que pedir ayuda en algún foro para intentar resolver el problema.

Existen también repositorios extraoficiales de paquetes binarios, siendo los más grandes LinuxPackages y Slacky.

GNOME

Por defecto Slackware no incluye el escritorio GNOME. Hay varias formas de incluirlo, la mejor hoy en día es GNOME SlackBuild. Incluye no solamente el escritorio sino también programas relacionados con él, como Rythmbox, Brasero, Mono y muchos más. Vale la pena tener disponibles los repositorios para incluir también programas que no son de GNOME pero Slackware no incluye y GSB sí, como OpenOffice.

Algunos enlaces interesantes:

• SlackwareCL: comunidad de usuarios de Slackware de Chile, tienen una guía que puede resultar interesante.
• Slacky: comunidad de usuarios de Italia.

Se supone que esta es solamente una guía básica para tener el sistema más o menos funcionando. Si algo no termina de quedar bien, recomiendo el excelente foro de Slackware en LinuxQuestions, o el no tan grande pero igualmente útil foro de Sistemas Unix en Foros del Web

El spam, o correo basura es sin duda alguna la parte más molesta de trabajar con correo electrónico.
Otros términos que se usan frecuentemente son UCE (siglas en inglés de Correo electrónico comercial no solicitado) o UBE (siglas en inglés de Correo electrónico masivo no solicitado).
La peor parte del correo basura es que los costos para quien lo envía es casi nulo. Quien debe asumir el costo de transporte, almacenamiento y filtrado (automático y manual) de los mensajes es el proveedor de correo del destinatario. También hay que considerar la pérdida de tiempo que insume el filtrado manual de los mensajes, sobretodo cuando la cuenta de correo ha sido comprometida y recibe grandes cantidades de basura.

Si bien los proveedores de correo tienen cada vez mejores filtros automáticos que nos evitan tener que eliminar manualmente la mayoría de los mensajes basura, aún hay muchas precauciones y buenas prácticas que uno puede tomar para evitar que la casilla se inunde.
Sobretodo es importante conocer y difundir las mejores prácticas, y enseñar a los novatos a reconocer las amenazas que el spam trae consigo (fraudes, estafas, venta de productos ilegales, etc). Aunque parezca increíble, hay mucha gente sin experiencia que cae con facilidad en estos engaños.

¿Cómo obtienen las direcciones de correo los spammers

Direcciones de correo visibles en la web

Los spammers (aquellos quienes envían el correo basura) utilizan varios métodos para recolectar nuestras direcciones de correo. Uno de ellos es el uso de robots que recorren las páginas web buscando direcciones. Es decir, si mi dirección de correo electrónico está públicamente visible en una página web, tarde o temprano un robot spammer la encontrará.

Cadenas

Por regla general las cadenas deberían eliminarse sin prestarles mucha atención. Sin embargo, las personas suelen reenviarlas a todos sus contactos, lo cual provoca que luego de 4 o 5 reenvíos el cuerpo del mensaje contenga decenas de direcciones. Si de casualidad el mensaje sigue reenviándose, podría caer eventualmente en poder de un spammer, muchas veces debido a troyanos u otra clase de programas maliciosos.

Sin entrar en los medios técnicos (que deberían estar a cargo de los administradores de los servidores de correo, no de los usuarios), aún hay algunas prácticas que pueden seguirse para evitar el daño causado por el correo basura.

Evitar el spam antes de que llegue

La mejor manera de evitar el correo basura es evitar que nuestra dirección de correo electrónico termine en la base de datos de algún delincuente (en muchos países del mundo el envío de spam es un delito).

Una buena práctica es tener al menos dos cuentas diferentes, una para uso personal y otra para suscripciones a sitios web. Con esto se expone solamente una de las cuentas, que además como no se utiliza para temas personales se puede reemplazar de forma sencilla si comienza a recibir gran cantidad de mensajes basura.

En conjunción con esta práctica, es importante dejar la dirección de correo solamente en sitios medianamente confiables, ya que uno nunca sabe qué puede hacer el creador del sitio con la información almacenada.

Otro punto a considerar es el de las cadenas, como se mencionó arriba. Todos tenemos algún conocido o amigo que no conoce (o pasa por alto) el problema que conlleva el reenviar correo incluyendo todas las direcciones en el campo Para, y sin borrar las cabeceras del mensaje que quiere reenviar.
Entonces, para evitar que nuestra cuenta termine en alguna máquina infectada por un troyano (que a su vez envíe la información al servidor de un spammer), es importante explicarle a la gente lo importante que es NO reenviar cadenas, o si se reenvían hacerlo con los cuidados necesarios: enviando solamente el contenido y no las cabeceras de los mensajes anteriores, y poniendo las direcciones en el campo CCO (copia oculta) en vez de en CC para que así cada destinatario no vea las direcciones de los demás.

Qué hacer cuando ya se está recibiendo correo basura

La mayoría de las veces la precaución no es suficiente: la cuenta comienza a recibir correo basura de todas formas.
La estrategia en este punto deja de ser unicamente la protección de la cuenta (aunque claramente esto se debe seguir haciendo) para pasar a ser el pretender que la cuenta no existe. Esto es, cualquier respuesta que se envíe a los spammers solamente logrará que nos llegue aún más basura. Por este motivo nunca, bajo ningún concepto, se debe responder a ningún correo no solicitado.

Pero no responder no es suficiente para fingir que la cuenta no existe: el cliente de correo que usemos nos puede traicionar (Thunderbird, Outlook Express, o incluso los clientes web de Gmail o Yahoo). Por esto se recomienda NO abrir mensajes sospechosos, o abrirlos únicamente si el cliente de correo está configurado para mostrarlos en modo texto.
El motivo es sencillo: si el cliente de correo admite formato de texto, admitirá imágenes y otras clases de archivos externos. Es muy sencillo incluir un código extra para que a la vez que se envía la petición para obtener esa imagen o archivo externo, se envíe una confirmación de que la cuenta de correo es válida.

No deberíamos tampoco hacer clic en ningún enlace que el correo incluya. En el pasado ha habido fallos en todos los clientes de correo y navegadores, que permiten ir hacia un sitio falseando su dirección. Es decir, cuando uno piensa que está en el sitio de su banco, al que llegó a través de un enlace en un correo, bien podría estar en realidad en un sitio fraudulento.

Una de las reglas generales que siempre deberían seguirse es: si el mensaje no fue solicitado, proceder con precaución. No importa si parece venir de una empresa o sitio web conocido, las direcciones de correo electrónico son fácilmente falseables. Incluso algo tan confiable a primera vista como soporte@microsoft.com podría ser en realidad un fraude.

Afortunadamente para nosotros los hispanohablantes, la mayoría del correo basura se envía en inglés. Por lo que si no tenemos ningún conocido que hable en inglés, se puede descartar con seguridad cualquier correo que no esté en español.

Nunca comprar

Hay que reconocerlo, a veces las ofertas de lo que se vende son interesantes. Pero con el bajo costo que tiene enviar un correo, una sola compra seguramente compense el envío de millones de mensajes no solicitados. Por este motivo es fundamental no comprar nada que se oferte a través de spam, ya que las ventas que se consiguen son el principal motivo para enviarlo (y eso sin contar que en la mayoría de los casos no se trata de comerciantes sino de estafadores, por lo que solamente terminaríamos perdiendo el dinero).

Sustitución de cuentas

A pesar de todo lo comentado, hay que saber reconocer cuando nos han vencido: si la cuenta de correo recibe demasiada basura, no queda otra opción que reemplazarla. Por esto es importante tener una cuenta para asuntos personales y otra para lo demás, es de suponer que la cuenta utilizada solamente para asuntos personales estará más protegida, menos gente la conocerá.

Lamentablemente, debido a los delincuentes una herramienta tan útil como el correo electrónico a veces se vuelve inusable. Es imprescindible entonces poner todos un granito de arena para evitar que la plaga se vuelva aún peor.

Los buscadores más importantes lo respetan (de otra forma su utilidad sería bastante escasa).

Hay varios motivos para usar un archivo robots.txt:

• Evitar el indexado de las imágenes
• Evitar que un robot consuma demasiado ancho de banda
• Dirigir a los buscadores a las páginas especialmente preparadas para ellos

¿Cómo crearlo?

El archivo robots.txt es un archivo de texto simple, que se ubica en la raíz del sitio. El formato del archivo es extremadamente simple, consta de 1 o más conjuntos, separados por una línea en blanco, de:

• Una línea User-agent, indicando el nombre de un robot o "*"; (todos los robots).

  Si bien la especificación de robotstxt.org no impone que se respeten mayúsculas y minúsculas, para máxima compatibilidad es mejor respetarlas. Esto es: escribir User-agent con la U mayúscula, y escribir el nombre del robot tal cual se identifica.

  Otro detalle a considerar es que no se aceptan expresiones regulares, solamente el nombre de un robot (y solo uno) o el asterisco "*" para que coincida con todos.

• Una o más líneas Disallow (no permitir), cada una indicando una carpeta o archivo del sitio que no se quiere que el robot (indicado por la línea User-agent) indexe. En esta línea tampoco se admiten comodines, debe darse la ruta completa. Cada línea Disallow debe contener solamente una ruta.

He aquí un ejemplo, en el que se niega a todos los robots el acceso a la carpeta /admin y al Googlebot el acceso a la carpeta /imagenes y al archivo /javascript/ultrasecreto.js

User-agent: * Disallow: /admin/ User-agent: Googlebot Disallow: /imagenes/ Disallow: /javascript/ultrasecreto.js

Los robots que respetan sus directivas lo buscan cada vez que se conectan a un servidor, así que si el archivo no existe se generarán muchos errores 404 causados por robots buscándolo.

¿Cómo saber el nombre que hay que usar para un robot?

La mayoría de los robots "serios" acompañan su cabecera User Agent con una URL en la que se puede encontrar información sobre ellos, que suele incluir los datos necesarios para guiar al robot usando el robots.txt.

Seguridad

Es importante destacar que aunque sirva para indicar a los robots por qué partes del sitio no deben entrar, el archivo robots.txt no debe ser usado como mecanismo de seguridad. Los robots reciben la indicación de no entrar, pero nada les impide hacerlo.
Además, todas las rutas que se indiquen quedan visibles para cualquiera que quiera verlas, nada impide a cualquier usuario ver el archivo, sobretodo considerando que siempre se encuentra en la misma ubicación (la raíz del sitio).

Si se necesita seguridad, se necesita un sistema basado en programación del lado del servidor, como siempre (ya sea un paquete PHP o autenticación HTTP)

Como suele suceder, el problema puede atacarse de diferentes formas. Hay sistemas que simplemente validan que la información ingresada contenga una arroba, hay otros que usan expresiones regulares complejas que fallan en cuanto la dirección ingresada no es común (aunque sea válida).
La forma que voy a plantear no es novedosa, y es bastante sencilla, a la vez que efectiva.

Una expresión regular permisiva

Debe poder validar a cualquier dirección de correo válida, esto quiere decir que debe ser también bastante genérica. El patrón debe validar que exista una arroba, un nombre de usuario, y una parte que indique el dominio.
A pesar de que probablemente nunca se usen nombres de usuario complejos en una dirección de correo, la verdad es que se puede usar cualquier caracter en esta parte de la dirección.
Por lo que la expresión regular que debe validar esto no puede ser otra que
.+
Que representa a una cadena conteniendo al menos 1 caracter.

El dominio es un poco más complicado. Muchos cometen el error de solamente permitir dos o tres partes separadas por punto, o rechazar direcciones cuya última parte contenga más de 3 caracteres. Con esto se supone que incluyen a todos los dominios de primer nivel (.com, .net, .org... y los de los países, que tienen 2 letras). Pero se olvidan que Internet cambia, y ya tenemos TLD .info y .aero (de cuatro letras) e incluso .museum (de seis).

Debido a esto, y considerando que lentamente están apareciendo los dominios con ñ y letras acentuadas, y que quizás pronto las direcciones comiencen a aceptar más caracteres UTF-8, es que también para validar el dominio se debe utilizar un patrón genérico.
El único requisito en este paso es que contenga al menos 2 secuencias de caracteres separadas por un punto. Debe haber al menos un punto, ya que no hay dominios que no desciendan de alguno de los TLD (en realidad sí los hay en redes locales, pero no sirven en internet).
.+\..+
Este patrón representa a una secuencia de caracteres no vacía, seguida de un punto, y seguida de otra secuencia de caracteres no vacía.

Finalmente, juntando las partes el patrón queda:
^.+@.+\..+$

Validación del dominio con PHP

Una versión anterior de este artículo recomendaba validar el dominio con checkdnsrr(). Esta parte ha sido eliminada, y el motivo es bastante simple, a decir verdad.

La función checkdnsrr solamente puede determinar si un dominio está registrado, y con el parámetro adecuado permite saber si el dominio tiene un registro MX (Mail eXchange) asociado (es decir, si es capaz de recibir correo). Pero una entrada DNS correcta no implica que realmente haya un servidor funcionando en el dominio.
Otras opciones, como gethostbyname por ejemplo, tienen sus propios problemas:

• Pueden fallar si el servidor remoto está temporalmente fuera de servicio, lo cual no es tan extraño en servidores pequeños.
• Si el equipo remoto no existe, la llamada a gethostbyname demora mucho en completarse, no por PHP sino por la forma en la que funciona el protocolo DNS.
• Podría haber un fallo de conectividad temporal de parte del servidor que ejecuta el programa PHP, lo cual provocaría que la función fallase.

Por estos motivos es que la validación del dominio funcionará en la mayoría de los casos pero fallará en otros, y si no se puede saber que será exitosa en todos los casos, no se puede confiar en ella.

De todas formas se incluyen los enlaces a las páginas del manual de PHP que corresponden a estas funciones, para que cada uno decida si hacer la validación o no.

Vale recordar lo que se mencionó al principio: no existe forma práctica de comprobar con certeza que la dirección es válida aún cuando se pudiese validar el dominio, dado que la dirección podría ser válida en forma pero no existir en el servidor, o podría estar mal escrita por error.
La única manera de saber con seguridad si la dirección es válida es enviar un correo de confirmación antes de habilitar al usuario a continuar en el sitio. Pero esto tampoco es la solución en todos los casos; a veces solicitar confirmación al usuario no tiene sentido (por ejempo en un formulario de contacto).

A continuación el código de mi función de validación:
function validar_correo($correo) { return preg_match('/^.+@(.+\..+)$/', $correo); }

A modo de resumen: la validación de direcciones de correo es compleja y no vale la pena intentar validar más que la forma. La mayoría de los métodos más estrictos con los que uno se puede llegar a encontrar suelen rechazar direcciones perfectamente correctas (aunque relativamente raras).

¿Cómo hacer para estar seguro de que un parámetro obtenido por GET (o POST) es un número entero?
Intentando resolver esta pregunta he intentado varias técnicas a lo largo del tiempo, y haciendo esas pruebas he llegado a entender más sobre cómo funcionan las comparaciones y las conversiones automáticas de tipos en PHP.

Convirtiendo a un valor entero

intval es una función que obtiene el valor entero de lo que se le pase como parámetro. Es equivalente a forzar una conversión anteponiendo (int) a un valor. Es decir, las siguientes dos líneas son equivalentes:
$valor = intval($parametro); $valor = (int) $parametro;

De esta forma se obtiene un valor entero en todos los casos, aunque no necesariamente este valor es igual al que queremos validar ya que cualquier cadena puede ser convertida a un entero, incluso una cadena que no contenga números (si no comienza con números, su valor es cero).

Pero una conversión no es una validación, así que debemos hallar una forma de asegurarnos de que el valor almacenado en $parametro es un número entero.

Primer intento: is_int

La primera idea es comprobar con la función is_int.
Esta función, como su nombre lo indica, comprueba que una variable sea de tipo entero, devolviendo true en caso de que lo sea, y false en caso contrario.

Parece ideal, sin embargo hay un problema: los valores que se reciben vía GET o POST son siempre cadenas, sin importar su contenido. El manual de la función lo advierte:

Para probar si una variable es un número o una cadena numérica (como en el caso de la entrada de un formulario, que es siempre una cadena), debe usar is_numeric().

Lo podemos comprobar fácilmente:
gettype($_GET['var']);
Devuelve "string", aunque el valor de $_GET['var'] sea 12, por ejemplo.
is_int($_GET['uno']);
Devuelve false, en el mismo caso que el anterior.

Segundo intento: is_numeric

La función is_numeric toma cualquier una variable (o valor) de cualquier tipo, y comprueba si tiene formato de número. Esto es, si es una cadena que representa un entero, o un flotante en cualquiera de las notaciones válidas para PHP.
Serviría para nuestro propósito si no fuese porque no acepta solamente enteros sino también números con coma (punto, en realidad), y por lo tanto devolverá true para un valor como 10.33, por ejemplo.

Tercer intento: comparación con entero

Otra opción puede ser hacer una comparación como
$_GET['var'] == (int) $_GET['var'];
En teoría funcionaría, pero no es así.
PHP es un tanto especial en lo que refiere a las conversiones de tipos: si uno de los valores a comparar es entero, convertirá al otro en entero antes de compararlos. Por lo tanto, la comparación propuesta siempre será cierta, ya que el lado izquierdo de la comparación será convertido. El resultado es que el código anterior es equivalente al siguiente, que es siempre verdadero y por lo tanto no nos sirve:
(int) $_GET['var'] == (int) $_GET['var'];

Cuarto intento: comparación de idénticos

Uno podría pensar que si PHP convierte a entero ambos lados y por eso no sirve el ejemplo anterior, bastaría con usar el operador === (comparación sin conversión) para saltear el problema. Pero no es así. Los valores siempre serán de tipos diferentes (ya que las variables GET son siempre cadenas) y por lo tanto la comparación sería siempre falsa.

Quinto intento: complicado pero funciona

Finalmente decidí probar algo más complejo pero que evita todos los problemas de los casos anteriores.

¿Qué hacer? La comparación con un entero es necesaria, porque después de todo lo que necesitamos es un entero, pero no podemos comparar una cadena con un entero porque la cadena será convertida.
La solución que se me ocurrió es simplemente volver a convertir al entero en una cadena:
$_GET['var'] == (string) intval($_GET['var']);o
$_GET['var'] == (string) (int) $_GET['var'];

Por ejemplo, si $_GET['var'] tiene el valor "12", el proceso sería:
intval("12") # --> entero 12 (string) intval("12") # --> cadena "12" "12" == "12" # --> verdadero, contienen el mismo valor.
Si ahora $_GET['var'] tiene el valor "hola":
intval("hola") # --> entero 0 (string) intval("hola") # --> cadena "0" "12" == "0" # --> falso, la cadena pasada no es un entero.
Y finalmente, el caso que hace que las conversiones fallen: una cadena con valores numéricos y letras. Supongamos que $_GET['var'] tiene el valor "12hola".
intval("12hola") # --> entero 12 (string) intval("12hola") # --> cadena "12" "12hola" == "12" # --> falso. Al evitar la conversión automática, no hay problemas.

Intento final: ctype_digit

Esta es una actualización de este artículo. Luego de mucho tiempo, di casi de casualidad con esta función, que sirve justamente para validar si una cadena contiene únicamente dígitos. Es increíble cómo uno puede utilizar un lenguaje durante años, y seguir encontrando cosas que no conocía, en particular esta función que no es para nada nueva, existe desde PHP 4.0.4

Es importante aclarar que esta función sirve solamente para variables de tipo cadena, ya que lo que hace es comprobar que cada caracter en el valor pasado como parámetro está en el rango ASCII que corresponde a los dígitos del 0 al 9 (valores entre 48 y 57 inclusive). No sirve para datos de tipo entero, y esto está claramente especificado en su página del manual.

Todo el trabajo que pasé intentando validar un entero se reduce, entonces a:
if (ctype_digit($variable)) { echo "La variable es entera"; }

CSV es un tipo de archivo de texto que contiene son archivos de valores separados por comas (de ahí su nombre). Es un formato bien simple y práctico.
No tiene una documentación oficial, pero buscando en internet encontré el RFC 4180, Common Format and MIME Type for Comma-Separated Values (CSV) Files. Al contrario de muchos RFC, que son especificaciones completas de formatos y protocolos, este parece ser simplemente un resumen de las características de los CSV, y un intento por documentar formalmente el formato.

Hay 5 reglas básicas que definen un archivo CSV, a saber:

1. Cada campo se separa con una coma, al último de la fila no le sigue una coma
2. No se toman en cuenta posibles espacios entre las comas separadoras.
3. Cada fila se separa con un salto de línea (CRLF, aunque se soporta también LF)
4. Los campos pueden o no estar delimitados por comillas (necesario en particular cuando se necesita incluir una coma en el campo o un salto de línea).
5. Si se necesita incluir comillas ", hay que duplicarlas: para que se tome "b" como el campo completo, hay que escribirlo como ""b""

Detalles

En caso de querer ponerlo para descargar, es bueno saber que el tipo MIME del formato es text/csv.
La codificación de caracteres por defecto se toma como US-ASCII, pero puede usarse el parámetro charset de la cabecera Content-Type para especificar otra. Si no se usa charset, el programa que trabaje con el archivo CSV deberá decidir qué codificación usa.
Este es el caso más común, ya que cuando uno abre el archivo con un programa como Excel u OpenOffice Calc, no existe una cabecera que indique el tipo MIME.

PHP provee 2 funciones para el manejo de estos archivos: fputcsv y fgetcsv.
fgetcsv extrae los campos separados por comas de un archivo, línea por línea, mientras que fputcsv permite hacer el proceso contrario.

Siendo un formato tan simple, resulta muy práctico para transmitir o almacenar información que luego debe ser procesada por otro sistema. También es la forma más sencilla de generar un archivo que pueda ser leído por los programas de hojas de cálculo (Excel, Calc, Gnumeric, etc), aunque no guarda información de formato de texto (negritas, colores, tamaños de letra, etc).

En caso de que no sea suficiente, siempre se puede recurrir a formatos más complejos, como XML o JSON.

Parte de este problema se resuelve teniendo una buena estructura de base de datos, con claves foráneas relacionando los campos correspondientes.

Pero para mayor seguridad, es bueno usar lo que en jerga databasera se conoce como transacciones.

Las transacciones sirven para asegurar la consistencia de la información, asegurando que un conjunto de sentencias se ejecuten correctamente, o no se ejecuten.

En un principio MySQL no las soportaba, esto cambió a partir de la versión 4, y con el uso de tablas InnoDB. Nótese que el motor por defecto para las tablas en MySQL hasta las versiones 5.* era MyISAM, que no soporta transacciones.

Un ejemplo

Supongamos que un sitio web bancario tiene 2 usuarios, ambos trabajando sobre la misma cuenta.

El usuario 1 pide incrementar su saldo en 10, mientras que el usuario 2 pide disminuirlo (a través de un formulario, por ejemplo)

El programador del sistema no puede decidir el orden en el que se ejecutarán las consultas, así que bien podría suceder lo siguiente:
$balance = ... SELECT balance FROM cuentas WHERE cuenta=X // usuario 1
$balance = ... SELECT balance FROM cuentas WHERE cuenta=X // usuario 2

En este punto, existen dos copias de la aplicación que contienen una variable $balance cada una. Supongamos que ambas necesitan actualizar el valor en la base de datos:
UPDATE cuentas SET balance=$balance+10 WHERE cuenta=X // usuario 1
UPDATE cuentas SET balance=$balance-10 WHERE cuenta=X // usuario 2
El resultado es que ambas copias del programa ejecutaron sus consultas con la información de balance que tenían, por lo que el resultado final es como si la consulta del usuario 1 no se hubiera ejecutado nunca, ya que el usuario 2 actualiza el registro con información vieja. Al final, en vez de quedar con el mismo saldo, la cuenta termina perdiendo 10.

Lo que se necesita para este conjunto de consultas, es lo que se denomina ACID, un acrónimo inglés que quiere decir Atomicidad, Consistencia, Aislamiento y Durabilidad. Recomiendo leer la información de Wikipedia para entender de qué se trata esto, pero lo importante es lo siguiente: las transacciones son un conjunto de consultas que se ejecutan como si fuesen una. Y por esto, permiten asegurar la consistencia de los datos, ya que si en mitad del proceso una consulta falla, todos los cambios producidos por consultas anteriores pueden ser revertidos.

¿Cómo usar transacciones?

Usar transacciones es muy simple: antes de ejecutar la primer consulta, se ejecuta una que solamente contiene BEGIN.
Luego se ejecutan las consultas que deban ejecutarse. Si éstas resultan exitosas, se termina la transacción con COMMIT
Esto provoca que los cambios hechos por las consultas anteriores sean permanentes.
Si las consultas fallan en algún paso, se puede volver al estado anterior al comienzo de la transacción ejecutando ROLLBACK

Aunque los datos no sean realmente escritos a la o las tablas involucradas hasta ejecutar el COMMIT, las consultas devuelven lo mismo que si lo fueran, es decir, para saber si una consulta falló basta con ver el valor de retorno de mysql_query y para ver el número de filas afectadas sigue valiendo usar mysql_num_rows

Mientras la transacción está ejecutándose, los datos (en el caso de InnoDB las filas y en el caso de MyISAM las tablas) afectados quedan bloqueados, nadie puede acceder a ellos. Cualquier consulta que tenga que ver con los mismos datos será demorada hasta que la transacción termine.
Esto implica que usar transacciones es un poco más lento que no usarlas, pero a la vez implica que los datos involucrados no pueden ser modificados por otra copia de la aplicación, y por lo tanto se evita la situación planteada al principio como ejemplo.

Dicha situación, implementada de forma "transaccional" quedaría:

mysql_query("BEGIN"); $balance = ..... mysql_query("SELECT balance FROM cuentas WHERE cuenta=X"); $resultado = mysql_query("UPDATE cuentas SET balance=$balance+10 WHERE cuenta=X"); if ($resultado !== false) // la consulta fue exitosa mysql_query("COMMIT"); else mysql_query("ROLLBACK");

(falta revisar que la consulta que obtiene el balance sea exitosa, pero de todas formas esto es solo un ejemplo)

autocommit

MySQL tiene una variable de entorno llamada autocommit, que por defecto tiene el valor 1. Configurado de esta manera no se pueden usar transacciones, porque MySQL automáticamente hace un COMMIT luego de cada consulta.

Para usar transacciones entonces, hay que poner autocommit a 0 (desactivarlo).
Nota: si autocommit se pone a cualquier número N > 1, MySQL hace un COMMIT automático luego de N consultas.

Para cambiar el valor de autocommit, simplemente se usa

SET autocommit = 0;

He aquí lo que sé sobre las transacciones. Es un tema interesante y cualquiera que programe un sistema relativamente complejo debería considerar si necesita transacciones para asegurar la "salud" de sus tablas y datos.

Como lamentablemente suele suceder, las versiones en inglés de los artículos de Wikipedia contienen información más detallada que las versiones en español.