Linux shell bash básico para principiantes

Extracto

@pedroruizhidalg― El shell es un intérprete de órdenes que proporciona una interfaz interactiva orientada a línea entre el usuario y el sistema operativo. Si bien existen varios shells, quizás es más común es Bash. Conocer desde un principio la estructura y posibilidades de este shell hará que adquieras unas habilidades en Linux que te mostrará su auténtica potencia.

Abreviaturas usadas

Bash: Bourne again shell.
EOF: End of file. Fin de fichero.

Descripción

Cuando en Linux abrimos un terminal desde nuestro entorno gráfico, o bien fuera de éste, queda a nuestra disposición una interfaz de linea de órdenes ―comandos― esta consola de linea de texto queda dispuesta para órdenes con sus opciones y argumentos. El el inductor shell es representado por el símbolo dolar como muestro a continuación:

$

Linux instala por defecto el shell bash, cuyo inductor es el símbolo dólar, no obstante cada shell en Linux puede tener su propio inductor. En este manual nos centraremos en Bash.

El shell bash es case sensitive, es decir distingue entre mayúsculas y minúsculas.

Ejecución

Empecemos poco a poco. La primera orden que vamos a introducir es «date», que obtiene la fecha y hora del sistema.

$ date
mié oct 21 14:16:37 CEST 2015
$

Esto muestra la hora y fecha en la que ha sido ejecutada esta orden. Dejando tras su ejecución de nuevo el inductor a la espera del siguiente comando.

Como forma general los comandos Linux tendrán la siguiente estructura:

$ Orden Opciones Argumentos
Opciones y argumentos

Una opción es un código seguido de una letra, o dos guiones seguidos de una palabra o palabras separadas por guiones. El comando ls, sin opciones, visualiza todos los archivos del directorio actual.

$ ls
carta1  carta2  micarta  todaslascartas
$

Con “-l” el comando ls modifica su salida y muestra una linea de información acerca de cada archivo.

$ ls -l
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 micarta
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 todaslascartas
$

Con la opción “a” muestra una lista de todos los archivos que haya en el directorio, incluso aquellos archivos que sean archivos ocultos. Los archivos ocultos llevan un punto al principio de su nombre.

Podemos unir las opciones “l” y “a” así “-l -a” o así “-la”.

$   ls -la
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 15:23 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

La mayoría de las órdenes han sido diseñadas para llevar argumentos. Como vimos arriba un argumento es una palabra que se teclea en la linea de órdenes tras las opciones. Veamos cómo se comporta el comando “ls” con las opciones “-la” y el argumento carta1.

$ ls -la carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1

En este caso hemos pedido al sistema la restricción de su salida haciendo que únicamente nos muestre el contenido del directorio que coincide con carta1. En este caso carta1 no es un archivo oculto. Hubiera producido el mismo resultado que la orden “ls -l carta1”.

Caracteres comodín y argumentos que son nombres de archivo

Los nombres de archivo son los argumentos más comunes en las órdenes. Es frecuente que sólo sepa ―recuerde― una parte del nombre, o tal vez le interese listar aquellos archivos que coinciden con un patrón determinado. Los caracteres comodín sirven para informar al sistema que la orden que estamos solicitando debe cumplir algunas coincidencias.

Carácter comodín *

Se usa para expresar como variable una parte de la cadena que estamos expresando.

$ ls -la carta*
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2

En otras palabras lista los archivos contenidos en el directorio cuyo nombre comience por “carta”.

¡Cuidado! determinadas órdenes y los comodines pueden producir una mezcla explosiva. Por ejemplo el comando “rm” sirve para eliminar archivos del directorio en que se está trabajando.

$ rm carta*

Borraría, en este caso, carta1 y carta2.

Seleccionar por extensiones

En Linux las extensiones de los archivos no son necesarias. No lo son para Linux, pero qué duda cabe que para los humanos sí, pues nos permite aislar fácilmente ese tipo de fichero del resto. Podemos usar el carácter comodín asterisco como discriminador por extensión.

$ ls -l *.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc

Nos muestra todos los archivos cuya extensión es “doc”.

El carácter comodín ?

Este comodín sirve para hacer coincidir una sola posición variable por cada aparición del carácter “?”. Veamos detenidamente el siguiente ejemplo:

$ ls -l *.?oc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
$ ls -l factura.?oc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
$ ls -l factura.*
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:22 factura.xls

En la primera orden solicitamos el listado de todos los archivos, sin importar su nombre, cuya extensión termine en “oc”: coinciden tres, documento.doc, factura.doc, factura.moc.

En la segunda orden pedimos todos los archivos cuyo nombre sea factura y su extensión termine en “oc”, coinciden factura.doc y factura.moc.

En la tercera queremos conocer todos los archivos cuyo nombre sea factura sin importar su extensión.

Caracteres comodín [ ]

Estos caracteres comodín se usan para indicar series. Por ejemplo:

$ ls -l carta[2-4]
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta3
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta4

Hemos seleccionado los documentos carta que terminan con los caracteres del 2 al 4, ecluyendo el 1. Otro ejemplo: pedimos listar los archivos carta2 y carta3 excluyendo los archivos carta1 y carta4.

 $ ls -l carta[2-3]
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta3
La entrada/salida estándar y redirección

Cuando fue diseñado Unix, se tomó la decisión de considerar la implementación física y la organización lógica de un archivo como cosas independientes. Físicamente se accede a los archivos de Unix como bloques que están dispuestos de forma aleatoria, si bien, lógicamente los archivos están dispuestos son un flujo continuo de bytes. Linux como versión de Unix mantiene la misma organización.

Por tanto cualquier archivo, a excepción de  algunas llamadas especiales al sistema, podrá ser copiado a otro archivo fácilmente. Para Linux no hay ninguna diferencia entre un archivo de caracteres y otro de registros, ni entre un archivo de texto y otro binario.

Esta organización lógica de archivos se extiende a las operaciones de entrada y salida. Los datos son organizados como en un archivo. De tal forma que la entrada para por teclado para Linux es un flujo continuo de datos. Igualmente, la salida estándar ―que es la pantalla― es otro receptor de flujos continuos de datos provenientes del sistema.

Esta característica hace de Linux un sistema en que es muy fácil crear salidas y entradas diferentes.

Redirección de la salida estándar: > y >>

Supongamos que en vez de ver el resultado de un comando por pantalla queremos, para observarlo más tranquilamente,  alterar la salida y crear un fichero con el resultado de un comando.

$ls -la > fichero.dir

$ cat fichero.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Con la primera orden efectuamos la redirección de la salida por pantalla hacia un archivo llamado “fichero.dir”. Con la segunda orden “cat” examinamos el contenido de dicho archivo. Como se puede observar se ha creado el archivo que consta con 864 bytes.

$ ls -l fichero.dir 
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:41 fichero.dir

Esto ha sido posible por el operador “>” puesto tras la orden “ls -l”. De igual forma podemos redireccionar la salida por pantalla de un archivo hacia otro archivo. Aunque hay un método más sencillo con el comando “cp” para copiar archivos, vamos a efectuar la una copia del archivo fichero.dir hacia otro archivo llamado copia.dir. Luego consultaremos cuántos archivos tienen la extensión .dir.

$ cat fichero.dir > copia.dir

$ ls -l *.dir
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:52 copia.dir
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:41 fichero.dir

Como se puede observar tanto los archivos copia.dir como fichero.dir tienen 864 bytes y fichero.dir fue creado a las 16:41 y copia.dir a las 16:52 horas.

Adición de la salida estándar: >>

Una vez asimilado el concepto de redirección de la salida, veamos el de adición. Si se repite la salida redirección de la salida estándar el fichero receptor de la salida es borrado y creado de nuevo. Pero tenemos la oportunidad de añadir información sin borrar la anterior. Esto se hace con el operador “>>”. Veamos un ejemplo. Vamos a volver a crear el archivo fichero.dir con el resultado de los archivos del directorio y le añadiremos el calendario del año 2015 con la orden “cal 2015”. Luego comprobaremos que el fichero ha cambiado de hora de creación.

$ ls -l > fichero.dir 

$ cal 2015 >> fichero.dir 

$ cat fichero.dir 
total 4
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:23 carta3
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:23 carta4
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:52 copia.dir
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:10 documento.asc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:20 factura.moc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:22 factura.xls
-rw-rw-r-- 1 pedro pedro   0 oct 21 17:01 fichero.dir
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 micarta
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:04 texto2
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 todaslascartas
                            2015
       Enero                Febrero                Marzo          
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
             1  2  3   1  2  3  4  5  6  7   1  2  3  4  5  6  7  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   8  9 10 11 12 13 14  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  15 16 17 18 19 20 21  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  22 23 24 25 26 27 28  
25 26 27 28 29 30 31                        29 30 31              
                                                                  

       Abril                  Mayo                 Junio          
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
          1  2  3  4                  1  2      1  2  3  4  5  6  
 5  6  7  8  9 10 11   3  4  5  6  7  8  9   7  8  9 10 11 12 13  
12 13 14 15 16 17 18  10 11 12 13 14 15 16  14 15 16 17 18 19 20  
19 20 21 22 23 24 25  17 18 19 20 21 22 23  21 22 23 24 25 26 27  
26 27 28 29 30        24 25 26 27 28 29 30  28 29 30              
                      31                                          

       Julio                 Agosto              Septiembre       
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
          1  2  3  4                     1         1  2  3  4  5  
 5  6  7  8  9 10 11   2  3  4  5  6  7  8   6  7  8  9 10 11 12  
12 13 14 15 16 17 18   9 10 11 12 13 14 15  13 14 15 16 17 18 19  
19 20 21 22 23 24 25  16 17 18 19 20 21 22  20 21 22 23 24 25 26  
26 27 28 29 30 31     23 24 25 26 27 28 29  27 28 29 30           
                      30 31                                       

      Octubre              Noviembre             Diciembre        
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
             1  2  3   1  2  3  4  5  6  7         1  2  3  4  5  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   6  7  8  9 10 11 12  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  13 14 15 16 17 18 19  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  20 21 22 23 24 25 26  
25 26 27 28 29 30 31  29 30                 27 28 29 30 31        
                                                                  
$ ls -l fichero.dir 
-rw-rw-r-- 1 pedro pedro 2936 oct 21 17:01 fichero.dir

La primera orden ha rehecho el archivo fichero.dir nuevamente con el listado de archivos. La segunda añade a archivo.dir el resultado de la orden “cal 2015” sin borrar, es decir añadiendo, los datos. La tercera orden muestra el contenido de archivo.dir con ambos resultados y en la cuarta orden podemos observar que fichero.dir ahora tiene 2936 bytes y ha sido creado a las 17:01 horas.

La entrada estándar

Muchas órdenes de Linux reciben los datos de la entrada estándar. Esa es la situación normal. La entrada estándar es el teclado. La entrada estándar como flujo de datos son introducidos por el teclado y dirigidos a la orden Linux. La orden “cat” sin argumento de nombre de archivo lee la entrada estándar y la redirige a la salida estándar ―pantalla―.

Antes de realizar el siguiente ejercicio tenemos que aprender que para todo linux la señal de fin de fichero (EOF) se realiza desde el teclado con “control-d” o “^D”.

$ cat 
estoy creando
estoy creando
una salida 
una salida 
desde la entrada estandar
desde la entrada estandar
^D
$

Como vemos lo que hace el comando cat sin argumentos es copiar lo que hemos tecleado desde la entrada estándar. Cuando pulsamos “control-d” acabamos la entrada y termina el proceso cat.

Vamos ahora a usar cat como recetor de un archivo. Es decir redireccionamos la entrada a cat desde el archivo copia.dir

$ cat < copia.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Vemos cómo hemos usado cat haciendo que la entrada fuera procedente del contenido del archivo copia.dir.

Se puede combinar las operaciones de redirección de la entrada como la salida estándares. En el siguiente ejemplo la orden cat no tiene argumentos de nombres de archivo. Sin argumentos toma la entrada desde el archivo copia.dir y redirecciona la salida a otracopia.dir.

$ cat < copia.dir > otracopia.dir
$ cat otracopia.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Mostrando a la vez el contenido de copia.dir y creando otro archivo llamado otracopia.dir.

Canalizaciones: |

Hay muchísimas ocasiones en las que se necesita enviar el resultado de una orden hacia otra orden. En otras palabras, se envía la salida estándar de una orden a la entrada de otra y no a un archivo. La canalización lpr se usa para enviar datos a la impresora.

$ ls -la | lpr

Hacemos que la salida estándar de ls -la la tome como entrada la orden lpr, como resultado esto llegará a la impresora.

Enviar un archivo a la impresora con cat -n imprimirá el archivo con el número de cada una de las líneas.

$ cat -n fichero.dir | lpr
Las canalización a more

Es una operación muy común canalizar el resultado de ls a la orden more ya que si el resultado prevemos que el resultado del listado de directorios sea demasiado grande, no nos dará tiempo a leerlo. El recurso ls -la | more, entrega al comando more el resultado de la orden ls, lo que permitirá que se detenga el listado hasta que llegue al final de la pantalla y esperará a que pulsemos la barra espaciadora para presentarnos otra página completa o intro para avanzar una sola linea.

$ ls -l /usr/bin | more

Presiona “q”, escape o “control-c” para salir.

Una canalización un poco más compleja. Usamos la orden sort para clasificar el contenido de un fichero dado, llamaremos a este fichero milista, la calalización de la salida estándar de sort se la entregamos a cat -n para que numere las líneas clasificadas, y esto lo canalizamos a la impresora. Así:

$ sort milista | cat -n | lpr

Otra canalización frecuente, se realiza con el comando tee, que se encarga de recoger la salida estandard y dirigirla al fichero especificado en tiempo real ―quiero decir conforme se efectúa la salida estándar―, en otras palabras, gravo en un fichero todo lo que sale por pantalla.

$ cat milista | tee nuevalista
Redirección y canalización del error estándar: >&, 2>

Observemos la siguiente secuencia de órdenes. Luego las explicaré.

$ cat ficheronoexiste
cat: ficheronoexiste: No existe el archivo o el directorio

$ cat ficheronoexiste > ficheronoexiste.err
cat: ficheronoexiste: No existe el archivo o el directorio

$ cat ficheronoexiste.err 

$ cat ficheronoexiste 2> ficheronoexiste.err

$ cat ficheronoexiste.err 
cat: ficheronoexiste: No existe el archivo o el directorio

En la primera orden intento obtener la salida estándar de ficheroquenoexiste ―de hecho no existe :-)― por eso Linux contesta indicándolo.

En la segunda de orden redirijo el flujo de la salida al fichero ficheronoexiste.err, que como vemos en este caso se crea, pero vacío, no contiene nada, porque nada produjo la orden cat.

En la tercera redirigimos el error con los caracteres “2> “ hacia fichernoexiste.err, en esta ocasión se crea con el contenido de la salida de errores producida por la orden cat.

No obstante si deseamos guardar los mensajes de error en el mismo archivo que use para la salida estándar, se necesita redireccionar el error estándar a la salida estándar. Es un poco lioso, lo vemos y lo explico.

$ cat fichernoexiste 1> otrofichero.err 2>&1

$ cat otrofichero.err 
cat: fichernoexiste: No existe el archivo o el directorio

La primera redirección la efectúo a otrofichero.err, la segunda redirección de error la devuelvo a &1, que es otra vez la salida estándar. Pero podemos simplificarlo:

Redirección de todo error a la salida estándar:

$ cat fichernoexiste >& ficheronoexiste.err
linux shell bash

linux shell bash

Epílogo

Esto sólo un compendio de lo que puede hacerse con bash. En el proyecto Lucas Bash podéis ampliar más. En una siguiente entrega describiré las variables en Bash.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[aquí la encuesta]
♻ miotroblogsite ahorra papel
Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s