
Oracle instant client es un cliente que nos permite conectar nuestra aplicación web a la base de datos Oracle.

La instalación de este cliente es algo complicada ya que hay poca documentación y el sitio oficial de Oracle no lo pone muy fácil para instalarlo. En este artículo instalaremos Oracle instant client en Ubuntu.

En la página oficial de Oracle descargaremos el [cliente](http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html). Es necesario registrarse para poder descargarlo.

Seleccionamos el cliente que nos interesa, generalmente:

Instant Client for Linux x86

Aceptamos el acuerdo de licencia y seleccionamos **oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.rpm** y **oracle-instantclient11.2-devel-11.2.0.3.0-1.i386.rpm**.

Podemos descargar también el SQL Developer, que es un programa de escritorio que se utiliza para hacer consultas y programar en PL/SQL en la base de datos Oracle, pero no lo necesitamos para conectar nuestra aplicación web a Oracle.

En Ubuntu/Debian los instalables suelen empaquetarse en archivos acabados en extensión .deb y los archivos descargados son .rpm, por lo que necesitaremos reconvertirlos. Para ello usaremos la aplicación alien, que si no la tenemos instalada podemos hacerlo con:

```bash
sudo apt-get install alien
```

Luego reconvertimos los archivos .rpm a .deb con:

```bash
alien oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.rpm
alien oracle-instantclient11.2-devel-11.2.0.3.0-1.i386.rpm
```

y luego usaremos el comando dpkg para instalarlos:

```bash
dpkg -i oracle-instantclient11.2-basic-11.2.0.3.0-1.i386.deb oracle-instantclient11.2-devel-11.2.0.3.0-1.i386.deb
```

# Instalar extensión oci8 en PHP

Si deseamos instalar el driver en PHP para poder conectar con una base de datos Oracle, podemos usar PECL para que nos lo instale. Usaremos:

```bash
sudo apt-get install libaio1
sudo apt-get install pecl
sudo pecl install oci8
```

Finalmente añadimos la extensión a php.ini, normalmente el archivo está en /etc/php5/apache/php.ini, y podemos añadir la linea en cualquier parte del archivo:

```bash
extension=oci8.so
```

Si se ha instalado correctamente, con la instrucción phpinfo() de PHP deberíamos ver el módulo OCI8.


Instalar el cliente de Oracle para conectarse usando PHP en Ubuntu

Oracle Instant Client en Ubuntu

oracle-instant-client-en-ubuntu


Presentamos un nuevo videotutorial para crear un efecto de texto en Photoshop parecido a un letrero con luz de neon. Los pasos a seguir son bastante simples. Aunque el tutorial está pensado para Photoshop CS6 o superiores, es compatible con versiones anteriores.

La letra usada para el logo es la fuente [neon](http://www.fontreactor.com/foundries/fenotype/neon), si os interesa otra fuente podéis navegar por los tipos de letra de la misma web [http://www.fontreactor.com](http://www.fontreactor.com)

La imagen de fondo usada como bloques de ladrillo podéis usar cualquiera de las [imagenes de Google](https://www.google.es/search?hl=es&q=bloques+de+ladrillo&bav=on.2,or.r_gc.r_pw.r_qf.&biw=1680&bih=925&um=1&ie=UTF-8&tbm=isch&source=og&sa=N&tab=wi&ei=_69VUOHTL426hAet0oFA#um=1&hl=es&tbm=isch&sa=1&q=bricks&oq=bricks&gs_l=img.3..0l10.3572.4202.0.4312.6.6.0.0.0.0.179.607.0j4.4.0...0.0...1c.1.L8O59Dnka-8&pbx=1&bav=on.2,or.r_gc.r_pw.r_qf.&fp=fa49fae0458b586c&biw=1680&bih=925).

Por último, recomiendo ver el video en HD a tamaño completo para ver los detalles correctamente.


Tutorial para crear paso a paso un efecto de texto de tipo neon en Photoshop CS6

Efecto de texto NEON con Photoshop

efecto-de-texto-neon-con-photoshop


A continuación os presentamos un script para generar sprites de iconos en GIMP. El script está codificado en Python.

Funciona en cualquier documento (PSD, etc) con un tamaño definido que será la dimensión del icono. En cada una de las capas se debe poner una imagen que representa el icono y con un nombre de capa determinado que luego se usará para definir los estilos CSS.

Para ejecutar el script dentro del editor gráfico GIMP (gratuito y de código abierto), tan solo hay que guardar este código en un archivo .py, por ejemplo **sprites.py** en la carpeta de Ubuntu: ~/.gimp-2.6/plug-ins (esto es dentro de nuestra home, por ejemplo, /home/miusuario/.gimp-2.6/plug-ins).

Luego reiniciamos el editor, abrimos el archivo donde tenemos las imágenes por capas y vamos al menú **Python-Fu > SpriteTool > Generate Sprites**

```python
#!/usr/bin/env python

# -*- coding: utf-8 -*-

from gimpfu import *

def to_sheet(image, drawable):
margin = 0
max_columns = 4

    css_output = ""
    col = 0
     row = 0

    number_of_layers = float(len(image.layers))
    sprite_x, sprite_y = image.width, image.height

    new_doc_width = max_columns * sprite_x + (max_columns - 1) * margin
    new_doc_height = math.ceil(number_of_layers  / max_columns) * sprite_y + ( math.ceil(number_of_layers  / max_columns) - 1) * margin

    image.resize(int(new_doc_width), int(new_doc_height), 0, 0)

    image.undo_group_start()

    # Move layers in sheet
    for layer in image.layers:
    if col > max_columns - 1:
    	col = 0
    	row += 1

    layerXPosition = layer.offsets[0]
    layerYPosition = layer.offsets[1]

    x = col * (sprite_x + margin);
    y = row * (sprite_y + margin);

        layer.set_offsets(x, y)
    col += 1
    	css_output += "\\n.icon-%(size_x)sx%(size_y)s-%(layer_name)s\\t{ background-position:  %(x_position)spx %(y_position)spx; }" % dict(size_x=sprite_x, size_y=sprite_y, layer_name = layer.name, x_position = ((-x) if (x != 0) else '0'), y_position = ((-y) if (y != 0) else '0') )

    image.undo_group_end()

    print css_output

if _name_ == '_main_':
register(
"redimensionar_imagen",
"Redimensionar imagen",
"Redimensionar imagen",
"",
"",
"2012",
"/Python-Fu/SpriteTool/Generate Sprites", "RGB*, GRAY*", [], [], to_sheet) main()
```

Script en Python para generar sprites de iconos con el editor gráfico GIMP

Generar sprites con Python y GIMP

generar-sprites-con-python-y-gimp


En las páginas web los formularios son elementos básicos para obtener información de los usuarios. Existen multitud de razones para crear un formulario y en la mayoría de webs encontrarás alguno, desde cajas de búsqueda, encuestas, introducción de datos para la identificación, etc.

En este artículo veremos la estructura básica de un formulario HTML y los componentes más habituales que lo forman.

Un ejemplo de formulario HTML podría ser este:

```html
<label for="name">Nombre:</label><input id="name" type="text"></input>
<label for="surname">Apellido:</label><input id="surname" type="text"></input>
```

En un formulario intervienen varios elementos. En el ejemplo anterior tan sólo se escriben las instrucciones para crear elementos del formulario: el formulario en sí mismo con la etiqueta **form**, las etiquetas label y los campos input.

## Consideraciones

Hay que tener en cuenta que un formulario como el del ejemplo no realiza ninguna acción. Para ello se utiliza la instrucción action, que es la ruta que manejará los datos del formulario. Para tratar estos datos suelen usarse lenguajes de lado del servidor como PHP, Ruby, Python, Java o cualquier otro que sea capaz de leer peticiones. Además, también hay que definir el método "method" que es cómo se enviarán los datos por el protocolo HTTP. Post suele ser el más habitual, pero también se permiten peticiones GET, PUT y DELETE. Aunque también depende del lenguaje o framework que se usará para interpretar los datos enviados.

También hay que decir que este formulario es solamente HTML, es decir, que no lleva maquetación, por lo que se necesitarían estilos CSS para estructurar el formulario gráficamente.


Estructura básica de un formulario en HTML

Formulario HTML

formulario-html


En linux existe una herramienta para rotar los logs del sistema, de modo que no se generen archivos de tamaño desorbitado y nos llene todo el espacio del disco.

La herramienta se llama **logrotate** y es muy sencilla de utilizar. La configuración general de logrotate se puede encontrar en /etc/logrotate.conf

Para configurar logrotate para unos logs en concreto, podemos crear un archivo en /etc/logrotate.d/

Podemos crear un archivo en esa carpeta para definir los logs que rotarán. Pueden haber varios definiciones en un mismo archivo. Un ejemplo de rotación podría ser:

```
/var/www/vhosts/miweb.com/log/production.log {
daily
missingok
rotate 30
compress
delaycompress
sharedscripts
postrotate
touch /var/www/vhosts/miweb.com/tmp/restart.txt
endscript
}
```

En nuestro ejemplo tras hacer la rotación se ejecuta el reinicio de una aplicación en Ruby on Rails en la etiqueta "postrotate", pero en otros casos puede cambiar según lo que se quiera, por ejemplo en un servidor apache se podría recargar la configuración del servidor con

```
postrotate
/etc/init.d/apache2 reload
endscript
```

O simplemente no hacer nada.

## Testear la configuración de logrotate

logrotate permite debuguear los scripts de configuración para ver si funcionan como esperamos, podemos ejecutar el comando con el parámetro -d

```bash
logrotate -d /etc/logrotate.d/nombredelarchivodeconfiguracion
```


Rotación automática de logs en linux con la aplicación logrotate

Rotar logs

rotar-logs


Buscar archivos desde la consola de Linux es una tarea complicada si eres nuevo en sistemas Linux.

Para buscar archivos el comando más común es el comando **find**. Este comando es muy potente y permite una infinidad de opciones para buscar tipos de archivos en todo el sistema. Veamos algunos ejemplos de cómo funciona.

## Buscar archivos y mostrar sus nombres

Para buscar todos los archivos dentro de un directorio con extensión .txt

```bash
find /home/miusuario -name "\*.txt"
```

Para encontar un archivo en todo el sistema, podemos buscarlo desde la carpeta raiz /

```bash
find / -name nombre_de_archivo
```

## Buscar archivos por nombre de usuario

Si deseamos buscar un archivo por nombre de usuario podemos escribir:

```bash
find / -user nombreusuario
```

Esto mostrará todos los archivos de ese usuario a partir de la carpeta raiz / y todas sus subcarpetas.

## Buscar archivos por tamaño de fichero

Para buscar archivos vacíos (el . indica el directorio en el que nos encontramos):

```bash
find . -size 0c
```

Para buscar archivos de un tamaño en kilobytes:

```bash
find . -size 54k
```

## Buscar por expresiones regulares

El comando find permite buscar utilizando expresiones regulares. Esto nos ofrece una potencia considerable. Por ejemplo si deseamos buscar archivos del tipo archivo01_01.txt, archivo02_03.txt, etc, podemos utilizar:

```bash
find . -regex './archivo0[1-2]_0[1-3].\*'
```

Además podemos anidar todas las opciones para hacer consultas más complejas.

## Buscando archivos con el comando Locate

También existe otra forma de buscar archivos en el índice del sistema, el comando locate.

Este comando funciona de la siguiente forma:

```bash
locate nombredelarchivo
```

Y devolverá todas las rutas en donde aparece el nombre entrado, podemos consultar dentro de los resultados devueltos por ejemplo:

```bash
locate miarchivo | grep bin
```

Devolverá todos las rutas del sistema que contengan el nombre miarchivo y que además también aparezca el texto bin.

Para actualizar el índice del sistema podemos utilizar el comando updatedb

```bash
sudo updatedb
```

Es recomendable ejecutarlo antes de hacer un locate para añadir las rutas recientes, por ejemplo si acabamos de instalar un programa.


Buscar archivos desde la linea de comandos en Linux

Buscar archivos en Linux

buscar-archivos-en-linux


FLV es un formato de vídeo (Flash Video) que se usa para transmitir videos por Internet utilizando Adobe Flash Player. Muchos sitios conocidos han adoptado este formato para transmitir videos, desde Youtube hasta MySpace. Esto es debido a la gran popularidad de Flash player, ya que está instalado en casi todos los ordenadores.

Avi (Audio Video Interleave) es otro formato de video creado por Microsoft en 1992. Para reproducir este formato es necesario un reproductor en el PC y no se puede visualizar en la web.

## De AVI a FLV

En linux podemos bajarnos la herramienta ffmpeg. En ubuntu podemos usar:

```bash
sudo apt-get install ffmpeg
```

Para convertir del formato de video FLV a AVI podemos utilizar la aplicación del siguiente modo.

```bash
ffmpeg -i mivideo.avi mivideo.flv
```

## De FLV a AVI

Si por el contrario, deseamos convertir un video de formato FLV a AVI podemos invertir el orden de los archivos utilizando la misma aplicación ffmpeg:

```bash
ffmpeg -i mivideo.flv mivideo.avi
```


Convertir un video con formato AVI a FLV y viceversa con ffmpeg

Convertir vídeos AVI a FLV

convertir-videos-avi-a-flv


Las expresiones regulares son patrones que se usan para encontrar combinaciones de caracteres en cadenas de texto. En Javascript, las expresiones regulares también son objetos. Hay varias funciones que nos permiten utilizar expresiones regulares en Javascript: la instrucción match, replace, search y split de la clase String.

Para comprobar si una cadena de texto encaja con el patrón dado podemos utilizar la función test, que devuelve true si encaja y false si no. Veamos algunos ejemplos útiles de uso de expresiones regulares:

## Validación de email

Patrón de validación para dirección de email

```regexp
/^(([^<>()[\\]\\\\.,;:\\s@\\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\\"]+)\*)|(\\".+\\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/.test("miemail@a.com")
```

La validación de email suele ser muy variable porque existen multitud de emails que son válidos, lo más común es que tengan un nombre de usuario, una arroba @ y un dominio.

## Colores HTML hexadecimales

Para validar si un color tiene el formato hexadecimal del estilo #FFFFFF

```regexp
/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test("#FFFFFF")
```

## Comprobar extensiones de archivos

Para determinar si unos archivos tienen una extensión permitida podemos usar:

```regexp
/^.\*\\.(txt|doc|docx)$/.test("miarchivo.docx")
```

_Estas expresiones no han sido testeadas al 100% por lo que no nos hacemos responsables de su corrección. Si vas a utilizarlas en algun entorno que requiera seguridad recuerda hacer tests._


Ejemplos de expresiones regulares en javascript utilizando la función test

Expresiones regulares en Javascript

expresiones-regulares-en-javascript


**.htaccess** es un archivo de configuración a nivel de directorios para varios servidores web.

En sistemas operativos Linux/Unix, es común utilizar archivos de este tipo para configurar directorios de una forma descentralizada, es decir, que cada directorio puede contener uno de estos archivos para configurar al directorio y sus subdirectorios.

El punto que hay delante del archivo .htaccess suele denotar que es un archivo oculto.

htaccess suele usarse en el servidor Apache y principalmente se utiliza para los siguientes casos para autentificación de directorios, para reescribir direcciones urls, para permitir o denegar direcciones IP de un dominio, para controlar cómo reaccionará el servidor cuando no encuentre una página, para gestionar la cache de los navegadores y los proxies, etc.

Veamos algunos ejemplos usuales:

## Mostrar mensaje de error personalizado

Para mostrar las típicas páginas de error 404 no encontrado y 500 error interno, podemos escribir las siguientes instrucciones:

```
ErrorDocument 500 /500.html
ErrorDocument 404 /404.html
```

Esto mostrará la página 500.html y 404.html respectivamente cuando el servidor muestre el código de error 500 y 404.

## Redireccionar

También es común redireccionar urls antiguas por nuevas usando la instrucción **redirect**

```
redirect /mi-direccion-antigua http://minuevodominio.com/minuevapagina
```


.htaccess es un archivo de configuración de Apache a nivel de directorio

htaccess


A partir de Java 5 se añadió una forma más conveniente para iterar sobre colecciones. En concreto usando la instrucción **for**. En muchos de lenguajes de programación se utiliza lo que se entiende como **for each** que traducido al español sería algo como "para cada". Hasta entonces Java no disponía de una manera leíble y entendedora hacer este tipo de bucles, encontrándonos en algunos casos con bucles for del tipo:

```java
void cancelAll(Collection c) {
    for (Iterator i = c.iterator(); i.hasNext();)
        i.next().cancel();
}
```

En este caso vemos cómo hacía falta hasta un iterador para navegar por la colección de datos.

## for each

Veamos un ejemplo de un foreach en Java tal y como se hace ahora:

```java
double[] coleccion = {5.0, 3.2, 1.8, 4.6};
int suma = 0;
for (double valor : coleccion) {
    suma += valor;
}
```

Dentro del for definimos el tipo de elemento (en este caso double) que contiene cada entrada de la colección.

Con este método conseguimos que el código sea sencillo, fácil de leer e intuitivo.


Uso de la función for each en Java. Exemplo práctico de foreach.

Java foreach

java-foreach


Aunque Javascript es un lenguaje de programación que siempre ha gozado de cierta popularidad, en los últimos años ésta se ha disparado.

A pesar de crearse en 1995 por Mozilla Foundation y por los creadores de Netscape, apenas ha sufrido cambios en su sintaxis, claramente basada en la sintaxis de Java.

CoffeScript es un intento de agilizar el proceso de escribir código en Javascript. Permitiendo al usuario centrarse en los algoritmos que ejecutarán sus programas en vez de escribir código farragoso.

CoffeScript es un lenguaje que compila en Javascript. Su traducción a Javascript es literal por lo que no hay interpretación en el tiempo de ejecución, es decir, se podría pasar de Coffee Script a Javascript y de Javascript a CoffeScript sin afectar al rendimiento ni perder código.

## Ejemplos CoffeScript a Javascript

Veamos algunos ejemplos sacados de su [página oficial](http://coffeescript.org/#language).

square = (x) -> x \* x
cube = (x) -> square(x) \* x

en javascript se convierte en:

var cube, square;

square = function(x) {
return x \* x;
};

cube = function(x) {
return square(x) \* x;
};

Un ejemplo de bucles:

eat food for food in ['toast', 'cheese', 'wine']

Se convierte en:

_ref = ['toast', 'cheese', 'wine'];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
food = _ref[_i];
eat(food);
}

## CoffeeScript y Ruby on Rails

CoffeeScript viene por defecto en las nuevas aplicaciones de Rails aunque su uso es totalmente opcional.

Desde mi punto de vista este lenguaje es útil si se desarrolla bastante en Javascript, puesto que ahorra mucho tiempo en escribir el código. Con el tiempo veremos si se establece o no.

## Probar CoffeScript

La página oficial de CoffeeScript permite probar código en tiempo real para ver cómo compila en Javascript. Podéis verlo en [CoffeeScript](http://www.coffeescript.org). En el menú superior en TRY COFFEESCRIPT.


CoffeeScript es un lenguaje que compila en Javascript.

CoffeeScript

coffeescript


Es frustrante terminar una web en la que hemos invertido muchas horas y con un contenido interesante pero que no consigue visitas. Mucha gente cree que al subir las páginas al servidor y enviarla a algun buscador como Google es suficiente para empezar a recibir visitas. Nada más lejos. Pero tranquilos, en este artículo veremos algunas técnicas fáciles y otras no tanto para empezar a generar tráfico.

## Agregar web a los buscadores

En la introducción decíamos que mucha gente sólo envía su web a Google. Esto no es suficiente para generar tráfico, pero es cierto que es un paso indispensable. Google es el mayor buscador de la red y sin duda el buscador que más tráfico nos puede aportar. Enviar la url a Google sirve para que nos añada a su indice, pero esto no implica que nos envíe visitas. A continuación explicaremos por qué, pero para empezar podéis enviar vuestra url a Google y a Bing

**Añadir url a Google**: [Google](http://www.google.es/addurl/)

**Añadir url a Yahoo o Bing**: [Bing](https://ssl.bing.com/webmaster/SubmitSitePage.aspx)

Para poder recibir visitas de los buscadores, es necesario que la web esté indexada en los buscadores y luego que esté bien posicionada (de aquí viene el término "posicionamiento web"). El primer paso y más sencillo ya lo hemos hecho, ahora lo difícil será posicionarla bien.

Posicionar una web en un buscador significa que al entrar un término de búsqueda en Google, este devuelve un listado con las webs más relacionadas con este término. Las posiciones superiores son las que más visitas recibirán de los usuarios y lógicamente las posiciones inferiores menos.

Para subir en el ranking de posicionamiento de un buscador debemos obtener enlaces de otros sitios o páginas hacia nuestra web. Esta es la principal forma en que los buscadores calculan qué posición merece un sitio en su listado.

## Gana links

Este es el punto más importante y básico para obtener tráfico y visitas a tu web.

Es cierto lo que se suele decir: El contenido es el rey. Significa que lo más valuoso de una web es el contenido, la temática del sitio, y por lo que los usuarios te visitarán, sin embargo, hoy en día, no es suficiente tener buen contenido debido a la gran competencia que existe.

Obviamente tener buen contenido retendrá a tus usuarios y es un buen sistema de fidelización, además, muchos usuarios enlazarán tu contenido de forma no interesada, puesto que puede ser un recurso útil. Y aunque este es un método válido, en ocasiones es muy lento.

Otra forma es localizar sitios parecidos al tuyo y contactar con sus administradores para pedirles que enlacen a vuestro sitio. Normalmente el otro usuario no accederá a publicar un enlace tuyo pero puedes ofrecerle un intercambio de enlaces, o incluso la forma más efectiva, pactar un importe económico para que publique un enlace en su web.

## Utiliza las redes sociales

Con el auge de las redes sociales como Facebook o Twitter, es necesario actuar y promocionar ahí tu web. Es lo más parecido al boca a boca, y en determinados casos, compartir webs a través de las redes sociales podría incrementar tu tráfico web de forma desmesurada.

Inscríbete a grupos de la temática de tu web, y participa sin hacer "spam". Si promocionas algo útil será bien recibido, e incluso puede que la gente lo comparta con sus amigos.

En tu sitio web también puedes añadir widgets y herramientas de estas redes sociales, como la caja de "me gusta" de Facebook en la que aparece el número de personas que les agrada tu página, o la caja de tweets de Twitter para mostrar los últimos tweets de tu canal.

## Listas de correo

Las listas de correo son una de las formas más antiguas y efectivas de promoción. Si tienes la posibilidad de crear una lista de correo y que los usuarios de tu web se suscriban, envía actualizaciones de forma periódica. Como hemos dicho antes, sin hacer spam, pero sí regularmente por ejemplo una vez a la semana o cada dos semanas, envía un correo a todos tus suscriptores explicándoles las novedades de tu sitio con enlaces hacia tus páginas.

Promocionar una web es un arte y algo que puede llevar mucho trabajo, pero siguiendo estas y otras muchas técnicas que iremos explicando se puede conseguir!


Técnicas más usuales para promocionar una página web

Promocionar página web

promocionar-pagina-web


SASS es el acrónimo de Syntactically Awesome Stylesheets. Es una extensión de CSS 3 que permite añadir variables, reglas anidadas y otras cualidades para escribir CSS de forma óptima.

Para diseñar proyectos de gran tamaño y que sean mantenibles se hace complicado usar sólo CSS. Uno de los ejemplos más claros es en el uso de la paleta de colores. En el diseño de nuestra web normalmente usaremos los mismos colores en varios sitios, con CSS normal se escribe la referencia hexadecimal o el nombre de color en cada sitio donde se usa. Esto puede generar problemas, por ejemplo si hay varios diseñadores o programadores modificando los estilos es fácil que alguien se equivoque y escriba o use otro color. Con SASS se pueden definir variables de manera que se definirán en un sólo sitio y en el resto del código se harán referencias a estas variables. En el caso de querer cambiar los colores también será mucho más sencillo y no traerá errores.

SASS está desarrollado en Ruby y normalmente se suele utilizar en el entorno de desarrollo. Una vez queramos subirlo en el entorno de producción, podremos utilizar desde la linea de comandos la instrucción SASS para convertir el código en CSS.

## SASS y Ruby on Rails

Des de la versión 3 de Rails, SASS se incluye por defecto en el paquete del framework, su uso es opcional, pero es una buena manera de empezar a usarlo.

Para más información sobre la sintaxis de SASS podéis ver su [página oficial](http://sass-lang.com)


Lenguaje para escribir CSS de forma rápida y eficiente

SASS

sass


En un artículo anterior vimos cómo configurar nuestra máquina para crear llaves SSH y poder conectar así con Github. Ahora veremos cómo crear un repositorio y explicaremos un poco cómo funciona todo.

## Crear un repositorio

Un repositorio GIT es el lugar dónde se almazenará nuestro código. Para crear uno en Github se puede acceder a esta página: [https://github.com/repositories/new](https://github.com/repositories/new). Github nos permite disponer de múltiples repositorios. En esa página pulsamos sobre **New repository** y rellenamos el formulario.

## Cómo subir código al repositorio

Primero en nuestra máquina nos situamos dentro de la carpeta donde tenemos el proyecto o código que subiremos.

Ahí inicializamos un repositorio local:

```bash
git init
```

A continuación podemos crear un archivo README que nos servirá como muestra de commit a subir. Además este archivo es el que usa Github para mostrar información del repositorio. Podemos añadir cualquier comentario dentro de este archivo de nombre **README**.

Luego hacemos un commit de la modificación:

```bash
git status
git add README
git commit -m "Initial commit"
git status
```

Ya hemos hecho commit en local. Podemos usar alguna herramienta como gitk para ver los commits. Se puede instalar usando:

```bash
sudo apt-get install gitk
gitk
```

Para subir el archivo al repositorio remoto de Github que hemos creado, debemos ejecutar los siguientes comandos:

```bash
git remote add origin git@github.com:username/Nombre-Proyecto.git
git push origin master
```

Si ahora nos dirigimos a nuestra cuenta de Github con el navegador, veremos que se ha subido el archivo README.


Pasos para crear y subir código en un repositorio de Github en linux.

Github. Crear un repositorio

github-crear-un-repositorio


Cacti es una potente herramienta para mostrar gráficos del rendimiento de una red. En este artículo veremos cómo instalarlo.

Para poder instalarlo hacen falta tener instaladas otras aplicaciones como PHP, Apache y Mysql.

## Instalación de Cacti

Para instalar cacti, podemos utilizar la siguiente instrucción:

```bash
apt-get install cacti
```

Aparecerá un asistente de instalación muy sencillo y fácil de usar.

El asistente nos puede informar que cambiemos la ruta de adodb. La cambiamos si la estamos usando en php.ini, sino podemos omitir este paso.

Luego nos pide qué servidor queremos usar. Aquí podemos seleccionar el que queramos, apache2 suele ser la opción más usual.

El asistente instalará varios paquetes y luego nos pedirá que necesita una base de datos instalada y configurada. A continuación nos pedirá la password root de MySQL y una nueva password para la nueva base de datos.

Una vez completada la instalación podemos ir a la página http://localhost/cacti/install/ y nos saldrá otro asistente de configuración.

Vamos pulsando siguiente y finalmente nos aparece una pantalla de login. El username y password por defecto son **admin** / **admin**. Seguidamente nos pedirá que cambiemos la password por una nuestra.

Ya podemos ver gráficas del rendimiento de nuestra red con Cacti!


Herramienta para mostrar gráficos del rendimiento de una red

Instalar Cacti

instalar-cacti


En este artículo veremos cómo crear claves SSH públicas y privadas autentificarnos en Github.

## Configurar claves SSH

Se utilizan claves SSH para establecer una conexión segura entre nuestro PC y GitHub. Configurar estas claves es muy simple.

Antes de nada veremos si ya tenemos alguna clave creada. Desde la terminal ejecutaremos:

```bash
ls ~/.ssh
```

Si no existe el directorio es que aun no hemos generado ninguna.

Si el directorio existe pero quieres seguir con el tutorial puedes hacer un backup de la carpeta .ssh y guardarla en un sitio seguro, para restablecerla si es necesario (o también puedes saltarte este paso).

Para generar una nueva clave SSH utiliza la siguiente instrucción:

```bash
ssh-keygen -t rsa -C "nombre@email.com"
```

Nos pedirá en qué archivo guardarlo. Podemos pulsar enter para seleccionar el nombre por defecto.

A continuación nos pedirá que entremos una passphrase. Una passphrase viene a ser una contraseña, normalmente más larga y con muchos caracteres diferentes. El sistema nos volverá a pedir de nuevo la passphrase para confirmarla.

## Añadir clave pública a GitHub

Tras ejecutar el paso anterior, se habrá creado una clave privada y una clave pública. La privada la deberemos guardar en algun lugar seguro y no mostrarla a nadie, la pública sin embargo, es la que usaremos para identificarnos con GitHub.

Crea una cuenta en [GitHub](http://www.github.com) si aun no la tienes. Luego ve a "Account Settings" > "SSH Public Keys" > "Add another public key".

En el formulario podemos entrar la llave pública que se encuentra en el archivo generado anteriormente "id_rsa.pub". En la carpeta ~/.ssh. Abrimos el archivo y copiamos todo el texto que hay dentro (desde el primer caracter hasta el último) y lo pegamos en el campo Key del formulario de GitHub.

Para probar que se ha configurado todo correctamente, se puede ejecutar este comando:

```bash
ssh -T git@github.com
```

Te aparecerá un mensaje en el que al final te pregunta:

```
The authenticity of host 'github.com (207.97.227.239)' can't be established.
RSA key fingerprint is 16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48.
Are you sure you want to continue connecting (yes/no)?
```

Escribe **yes** y pulsa enter. Si todo ha ido bien te aparecerá el mensaje de identificación satisfactoria:

```
Hi nombreusuario! You've successfully authenticated, but GitHub does not provide shell access.
```

## Configurar información personal

Podemos configurar Git para añadir nuestro nombre y email, de modo que Github pueda mostrarlos al hacer commits.

```bash
git config --global user.name "Nombre Apellido"
git config --global user.email "tuemail@email.com"
```


Cómo crear las llaves SSH y configurar tu cuenta de GitHub

Configurar GIT para trabajar con GitHub

configurar-git-para-trabajar-con-github


Facebook es la red social con más usuarios del mundo, tiene cientos de millones de personas registradas. Si dispones de un producto que anunciar o incluso si quieres hacer una página de fans, la base de usuarios a la que puede llegar es enorme.

En este artículo veremos los pasos a seguir para crear una página en Facebook. Para empezar, visita la página oficial de [Facebook](http://www.facebook.com/pages/create.php)

## Categorías de páginas

En esta página se puede seleccionar el tipo de contenido que queremos anunciar o la temática de nuestra página Facebook. Se puede escoger de entre 6 categorías:

Lugar o negocio local  
Empresa, organización o institución  
Marca o producto  
Artista, grupo de música o personaje público  
Entretenimiento  
Causa o comunidad

Al pulsar sobre cualquiera de ellas, en la misma página nos aparecerá el formulario para completar los datos de la página.

Si aun no estás identificado en la red social, identifícate y posteriormente se habrá creado la página.


Crear página en Facebook

crear-pagina-en-facebook


Enviar un email con HTML puede parecer simple, pero es una tarea que requiere cierto trabajo, puesto que el soporte de CSS y en HTML en los clientes de email es bastante inferior de lo que lo es para los navegadores.

En este artículo veremos qué hay que tener en cuenta para diseñar una newsletter y que sea visible en la mayoría de clientes de correo electrónico (Gmail, Hotmail, Outlook, etc).

El principal problema radica en que estas aplicaciones carecen de un buen soporte para CSS, haciendo que toda la flexibilidad y modernidad alcanzada con el diseño de páginas web en los navegadores de hoy en día se vaya literalmente al traste.

## Consejos

**Utilizar estilos _inline_**. Los clientes de email tratan de limitar la carga de archivos externos, y por ende, no permiten los archivos de estilos css. Es por eso que todos los estilos deberán escribirse dentro del mismo código HTML.

**Utilizar tablas**. Utilizar contenedores DIV en HTML para newsletters es una mala idea. Hay que utilizar tablas para asegurarnos de que todos los programas lo renderizan correctamente. En la maquetación web de hoy en día el uso de tablas ha quedado desfasada debido a la gran cantidad de código HTML que se genera, pero, sin embargo, se recupera para la maquetación de emails. No olvides tampoco definir para las celdas y tablas un cellspacing y cellpadding

**Probar multiples clientes**. Que se vea la newsletter bien en un cliente no implica que en los demás lo haga, por lo que se recomienda probarlo con más de uno. También se recomienda añadir un enlace en la misma newsletter para permitir al usuario verla en el navegador en caso de que tenga problemas para renderizarla.

Escribir los atributos de altura y anchura (width & height) como tags HTML en vez de en los estilos.

Escribir texto alternativo para imágenes. En ocasiones algunos clientes, como Gmail, no muestran las imágenes por defecto hasta que no pulsas un link para permitirlo. Esta bien en esos casos que el usuario pueda ver un texto alternativo usando el tag alt de HTML para que sepa que hay una imagen.

Utiliza rutas absolutas para que los contenidos descargables como imágenes se vean. Es común olvidarse de ponerlos y como en nuestro entorno los vemos, luego al enviar la newsletter aparece sin imágenes.

## Cosas a evitar

No utilizes archivos css externos, o css entro de los tags style en los encabezamientos head HTML. La gran mayoría de clientes omitiran el contenido y mostrarán sólo el cuerpo (body).

No utilizar javascript. Javascript podría contener código malicioso, por lo que los clientes lo ignoran. Incluso pueden marcarlo como SPAM.


Consejos para añadir HTML y css en los emails

CSS y HTML en newsletters

css-y-html-en-newsletters


## ¿Qué es YAML?

YAML es un formato para guardar objetos de datos con estructura de árbol. Sus siglas significan YAML Ain't Markup Language (YAML no es otro lenguaje de marcado).

Este lenguaje es muy legible para las personas, más legible que JSON y sobretodo que XML.

Normalmente se utiliza para definir archivos de configuración, aunque también es posible serializar objetos, es decir, escribir la estructura de un objeto en modo cadena de texto para posteriormente poderlo recuperar. Sin embargo, para este propósito es bastante más lento que utilizar JSON.

Hay librerías para todos los lenguajes de programación, desde Ruby, PHP, Java hasta C# entre otros.

Ruby on rails por ejemplo lo utiliza mucho en sus archivos de configuración. Veamos una muestra del archivo de configuración de las bases de datos (database.yml).

development:
database: mi_app_development
adapter: mysql
host: localhost

test:
database: mi_app_test
adapter: mysql
host: localhost

La estructura del archivo es de tipo clave-valor. Además es importante la indentación, para definir la estructura de árbol padre-hijo.

También es común utilizar YAML en archivos de traducción. Por ejemplo:

es:
errors:
format: ""
messages:
greater_than_or_equal_to: debe ser mayor o igual a %{count}
not_found: no encontrado
already_confirmed: ya ha sido confirmada
less_than: debe ser menor que %{count}
date:
formats:
default: "%d/%m/%Y"
short: "%d/%m"
long: ""

## Sintaxis alternativa

Para serializar objetos, YAML utiliza otra sintaxis para permitir escribir estructuras más complejas sin indentación. Veamos un ejemplo en Ruby:

Un hash del tipo:

{
:etiqueta1 => 1,
:etiqueta2 => 2
}

en YAML quedaría así:

\---
:etiqueta1: 1
:etiqueta2: 2

## De archivo en formato YAML a objeto

En Ruby es muy simple cargar un archivo de configuración YAML, tan solo utilizando:

require 'yaml'
YAML.load(File.open("/tmp/ejemplo.yml"))

Obtendríamos el contenido del archivo deserializado y listo para usar.

## De objeto a YAML

Y para pasar el contenido de una varialbe a YAML usaríamos el método to_yaml:

{
:etiqueta1 => 1,
:etiqueta2 => 2
}.to_yaml


¿Qué es el lenguaje YAML? Cuando usarlo y para qué sirve

YAML

yaml


Trabajar con JQuery para enviar formularios AJAX es muy sencillo. A continuación veremos cómo hacer un formulario usando Javascript y que los datos se envien de forma asíncrona para que sea transparente para el usuario.

El código HTML del formulario podría ser:

```js
$('#boton_enviar').click(function(evt) {
  $.ajax({
    cache: false,
    async: false,
    type: 'POST',
    data: {
    parametro1: $('#id_del_campo1').val(),
    parametro2: $('#id_del_campo2').val()
  },
  url: '/direccion-url/',
  dataType: 'json',
  beforeSend: function(){
    $('#boton_enviar').attr('disabled', true);
  },
  success: function(response) {
    if(response.success == true){
      $('#respuesta').html(response.message);
    } else {
        $('#boton_enviar').attr('disabled', false);
    }
  },
  error: function(msg){
    $('#boton_enviar').attr('disabled', false);
  }
  });
  evt.preventDefault();
});
```

La mayoría de atributos se explican por si solos pero vale la pena destacar alguno. Uno de los más importantes es el campo **url** que es la dirección que procesará los datos del formulario que se envien.

Otro es el atributo **success** que tratará la respuesta que recibiremos del servidor.

Esta respuesta que será el procesador del formulario y que se puede programar en cualquier lenguaje (PHP, Java, Ruby, etc), deberá tratar los parámetros, y devolver una estructura JSON de respuesta del tipo:

```json
{"success":true, "message":"Enviado correctamente"}
```

Si el resultado ha sido satisfactorio o bien

```json
{"success":false, "message":"Error en el formulario"}
```

## Método preventDefault()

En el form del ejemplo anterior, en la declaración HTML no hemos puesto ningun atributo action, que sería la url donde se enviaría el formulario si no fuera un envío AJAX. Pero de todas formas, si pusieramos alguna no pasaría nada, pues utilizamos el método **preventDefault** de Jquery al final de la función AJAX para evitar que se siga el flujo habitual al presionar el botón de enviar el formulario.


Enviar datos de un formulario de forma asíncrona (AJAX) en Javascript utilizando el framework JQuery

Todos los artículos