From 86544181686161ad39dd9f7dd626347816d77b84 Mon Sep 17 00:00:00 2001
From: Damaso Sanoja <narsil.dev@gmail.com>
Date: Sat, 17 Oct 2015 08:18:34 -0430
Subject: First Draft

---
 es-es/amd-es.html.markdown | 423 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 423 insertions(+)
 create mode 100644 es-es/amd-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown
new file mode 100644
index 00000000..3de23a6c
--- /dev/null
+++ b/es-es/amd-es.html.markdown
@@ -0,0 +1,423 @@
+---
+
+category: tool
+
+tool: amd
+
+contributors:
+
+    - ["Frederik Ring", "https://github.com/m90"]
+
+translators:
+
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+
+filename: learnamd-es.js
+
+lang: es-es
+
+---
+
+
+
+## Iniciando con AMD
+
+
+
+El API del **Módulo de Definición Asíncrono** especifica un mecanismo para definir módulos
+
+JavaScript de manera que tanto el módulo como sus dependencias puedan ser cargadas de manera asíncrona. Esto es particularmente adecuado para el entorno del navegador donde la carga sincronizada de los módulos genera problemas de rendimiento, usabilidad, depuración y acceso cruzado de dominios.
+
+
+
+### Conceptos básicos
+
+```javascript
+
+// El API básico de AMD consiste en nada más que dos métodos: `define` y `require`
+
+// y se basa en la definición y consumo de los módulos:
+
+// `define(id?, dependencies?, factory)` define un módulo
+
+// `require(dependencies, callback)` importa un conjunto de dependencias y
+
+// las consume en el callback invocado
+
+
+
+// Comencemos usando define para definir un nuevo módulo
+
+// que no posee dependencias. Lo haremos enviando un nombre
+
+// y una función factoría para definirla:
+
+define('awesomeAMD', function(){
+
+  var isAMDAwesome = function(){
+
+    return true;
+
+  };
+
+  // El valor que regresa de la función factoría del módulo es
+
+  // aquello que los otros módulos o llamados require reciben cuando
+
+  // solicitan nuestro módulo `awesomeAMD`.
+
+  // El valor exportado puede ser cualquier cosa, funciones (constructores),
+
+  // objetos, primitivos, incluso indefinidos (aunque eso no ayuda mucho).
+
+  return isAMDAwesome;
+
+});
+
+
+
+// Ahora definamos otro módulo que dependa de nuestro módulo `awesomeAMD`.
+
+// Observe que ahora hay un argumento adicional que define 
+
+// las dependencias de nuestro módulo:
+
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+
+  // las dependencias serán enviadas a los argumentos de la factoría
+
+  // en el orden que sean especificadas
+
+  var tellEveryone = function(){
+
+    if (awesomeAMD()){
+
+      alert('This is sOoOo rad!');
+
+    } else {
+
+      alert('Pretty dull, isn\'t it?');
+
+    }
+
+  };
+
+  return tellEveryone;
+
+});
+
+
+
+// Como ya sabemos utilizar define usemos ahora `require` para poner en marcha
+
+//  nuestro programa. La firma de `require` es `(arrayOfDependencies, callback)`.
+
+require(['loudmouth'], function(loudmouth){
+
+  loudmouth();
+
+});
+
+
+
+// Para hacer que este tutorial corra código, vamos a implementar una
+
+// versión muy básica (no-asíncrona) de AMD justo aquí:
+
+function define(name, deps, factory){
+
+  // observa como son manejados los módulos sin dependencias
+
+  define[name] = require(factory ? deps : [], factory || deps);
+
+}
+
+
+
+function require(deps, callback){
+
+  var args = [];
+
+  // primero recuperemos todas las dependencias que necesita
+
+  // el llamado require
+
+  for (var i = 0; i < deps.length; i++){
+
+    args[i] = define[deps[i]];
+
+  }
+
+  // satisfacer todas las dependencias del callback
+
+  return callback.apply(null, args);
+
+}
+
+// puedes ver este código en acción aquí: http://jsfiddle.net/qap949pd/
+
+```
+
+
+
+### Uso en el mundo real con require.js
+
+
+
+En contraste con el ejemplo introductorio, `require.js` (la librería AMD más popular) implementa la **A** de **AMD**, permitiéndote cargar los módulos y sus dependencias asincrónicamente via XHR:
+
+
+
+```javascript
+
+/* file: app/main.js */
+
+require(['modules/someClass'], function(SomeClass){
+
+  // el callback es diferido hasta que la dependencia sea cargada
+
+  var thing = new SomeClass();
+
+});
+
+console.log('So here we are, waiting!'); // esto correrá primero
+
+```
+
+
+
+Por convención, usualmente guardas un módulo en un fichero. `require.js` puede resolver los nombres de los módulos basados en rutas de archivo, de forma que no tienes que nombrar tus módulos, simplemente referenciarlos usando su ubicación. En el ejemplo `someClass` es asumido que se ubica en la carpeta `modules`, relativa a tu `baseUrl` configurada:
+
+
+
+* app/
+
+  * main.js
+
+  * modules/
+
+    * someClass.js
+
+    * someHelpers.js
+
+    * ...
+
+  * daos/
+
+    * things.js
+
+    * ...
+
+
+
+Esto significa que podemos definir `someClass` sin especificar su id de módulo:
+
+
+
+```javascript
+
+/* file: app/modules/someClass.js */
+
+define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
+
+  // definición de módulo, por supuesto, ocurrirá también asincrónicamente
+
+  function SomeClass(){
+
+    this.method = function(){/**/};
+
+    // ...
+
+  }
+
+  return SomeClass;
+
+});
+
+```
+
+Para alterar el comportamiento del mapeo de ruta usa `requirejs.config(configObj)` en tu `main.js`:
+
+
+
+```javascript
+
+/* file: main.js */
+
+requirejs.config({
+
+  baseUrl : 'app',
+
+  paths : {
+
+    // también puedes cargar módulos desde otras ubicaciones
+
+    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+
+  }
+
+});
+
+require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
+
+  // un fichero `main` necesita llamar a require al menos una vez,
+
+  // de otra forma jamás correrá el código
+
+  coolLib.doFancyStuffWith(helpers.transform($('#foo')));
+
+});
+
+```
+
+Las aplicaciones basadas en `require.js` usualmente tendrán un solo punto de entrada (`main.js`) que se pasa a la etiqueta del script `require.js` como un atributo de datos. Será cargado y ejecutado automáticamente al cargar la página:
+
+
+
+```html
+
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+  <title>Cien etiquetas de script? Nunca más!</title>
+
+</head>
+
+<body>
+
+  <script src="require.js" data-main="app/main"></script>
+
+</body>
+
+</html>
+
+```
+
+
+
+### Optimizar todo un proyecto usando r.js
+
+
+
+Muchas personas prefiere usar AMD para la sana organización del código durante el desarrollo, pero todavía prefiere enviar para producción un solo fichero en vez de ejecutar cientos de XHRs en las cargas de página.
+
+
+
+`require.js` incluye un script llamado `r.js` (el que probablemente correrás en node.js, aunque Rhino también es soportado) que puede analizar el gráfico de dependencias de tu proyecto, y armar un solo fichero que contenga todos tus módulos (adecuadamente nombrados), minificado y listo para consumo.
+
+
+
+Instálalo usando `npm`:
+
+```shell
+
+$ npm install requirejs -g
+
+```
+
+
+
+Ahora puedes alimentarlo con un fichero de configuración:
+
+```shell
+
+$ r.js -o app.build.js
+
+```
+
+
+
+Para nuestro ejemplo anterior el archivo de configuración luciría así:
+
+```javascript
+
+/* file : app.build.js */
+
+({
+
+  name : 'main', // name of the entry point
+
+  out : 'main-built.js', // name of the file to write the output to
+
+  baseUrl : 'app',
+
+  paths : {
+
+    // `empty:` tells r.js that this should still be loaded from the CDN, using
+
+    // the location specified in `main.js`
+
+    jquery : 'empty:',
+
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+
+  }
+
+})
+
+```
+
+
+
+Para usar el fichero creado en producción, simplemente intercambia `data-main`:
+
+```html
+
+<script src="require.js" data-main="app/main-built"></script>
+
+```
+
+
+
+Un increíblemente detallado [resumen de opciones de generación](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponible en el repositorio de GitHub.
+
+
+
+### Tópicos no cubiertos en este tutorial
+
+* [Cargador de plugins / transformaciones](http://requirejs.org/docs/plugins.html)
+
+* [Cargando y exportando estilos CommonJS](http://requirejs.org/docs/commonjs.html)
+
+* [Configuración avanzada](http://requirejs.org/docs/api.html#config)
+
+* [Configuración de Shim (cargando módulos no-AMD)](http://requirejs.org/docs/api.html#config-shim)
+
+* [Cargando y optimizando CSS con require.js](http://requirejs.org/docs/optimization.html#onecss)
+
+* [Usando almond.js para construcciones](https://github.com/jrburke/almond)
+
+
+
+### Otras lecturas:
+
+
+
+* [Especificaciones oficiales](https://github.com/amdjs/amdjs-api/wiki/AMD)
+
+* [¿Por qué AMD?](http://requirejs.org/docs/whyamd.html)
+
+* [Definición Universal de Módulos](https://github.com/umdjs/umd)
+
+
+
+### Implementaciones:
+
+
+
+* [require.js](http://requirejs.org)
+
+* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+
+* [cujo.js](http://cujojs.com/)
+
+* [curl.js](https://github.com/cujojs/curl)
+
+* [lsjs](https://github.com/zazl/lsjs)
+
+* [mmd](https://github.com/alexlawrence/mmd)
-- 
cgit v1.2.3


From 0f003ef3e9fc00c33741303e4979a44f285f5e05 Mon Sep 17 00:00:00 2001
From: Damaso Sanoja <narsil.dev@gmail.com>
Date: Sat, 17 Oct 2015 11:35:56 -0430
Subject: Spanish translation version 1

---
 es-es/amd-es.html.markdown | 241 +++------------------------------------------
 1 file changed, 16 insertions(+), 225 deletions(-)

(limited to 'es-es')

diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown
index 3de23a6c..7a59ddd6 100644
--- a/es-es/amd-es.html.markdown
+++ b/es-es/amd-es.html.markdown
@@ -1,423 +1,214 @@
 ---
 
 category: tool
-
 tool: amd
-
 contributors:
-
     - ["Frederik Ring", "https://github.com/m90"]
 
 translators:
-
     - ["Damaso Sanoja", "https://github.com/damasosanoja"]
-
 filename: learnamd-es.js
-
 lang: es-es
-
 ---
 
-
-
 ## Iniciando con AMD
 
-
-
-El API del **Módulo de Definición Asíncrono** especifica un mecanismo para definir módulos
-
-JavaScript de manera que tanto el módulo como sus dependencias puedan ser cargadas de manera asíncrona. Esto es particularmente adecuado para el entorno del navegador donde la carga sincronizada de los módulos genera problemas de rendimiento, usabilidad, depuración y acceso cruzado de dominios.
-
-
+El API del **Módulo de Definición Asíncrono** especifica un mecanismo para definir módulos JavaScript de manera tal que tanto el módulo como sus dependencias puedan ser cargadas de manera asíncrona. Esto es particularmente adecuado para el entorno del navegador donde la carga sincronizada de los módulos genera problemas de rendimiento, usabilidad, depuración y acceso de multi-dominios.
 
 ### Conceptos básicos
-
 ```javascript
-
-// El API básico de AMD consiste en nada más que dos métodos: `define` y `require`
-
+// El API básico de AMD consiste en tan solo dos métodos: `define` y `require`
 // y se basa en la definición y consumo de los módulos:
-
-// `define(id?, dependencies?, factory)` define un módulo
-
-// `require(dependencies, callback)` importa un conjunto de dependencias y
-
-// las consume en el callback invocado
-
-
+// `define(id?, dependencias?, fábrica)` define un módulo
+// `require(dependencias, callback)` importa un conjunto de dependencias y
+// las consume al invocar el callback
 
 // Comencemos usando define para definir un nuevo módulo
-
 // que no posee dependencias. Lo haremos enviando un nombre
-
-// y una función factoría para definirla:
-
+// y una función fábrica para definirla:
 define('awesomeAMD', function(){
-
   var isAMDAwesome = function(){
-
     return true;
-
   };
-
-  // El valor que regresa de la función factoría del módulo es
-
-  // aquello que los otros módulos o llamados require reciben cuando
-
-  // solicitan nuestro módulo `awesomeAMD`.
-
+  // El valor que regresa la función fábrica del módulo será
+  // lo que los otros módulos o llamados require recibirán cuando
+  // soliciten nuestro módulo `awesomeAMD`.
   // El valor exportado puede ser cualquier cosa, funciones (constructores),
-
   // objetos, primitivos, incluso indefinidos (aunque eso no ayuda mucho).
-
   return isAMDAwesome;
-
 });
 
-
-
 // Ahora definamos otro módulo que dependa de nuestro módulo `awesomeAMD`.
-
 // Observe que ahora hay un argumento adicional que define 
-
 // las dependencias de nuestro módulo:
-
 define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
-
-  // las dependencias serán enviadas a los argumentos de la factoría
-
+  // las dependencias serán enviadas a los argumentos de la fábrica
   // en el orden que sean especificadas
-
   var tellEveryone = function(){
-
     if (awesomeAMD()){
-
       alert('This is sOoOo rad!');
-
     } else {
-
       alert('Pretty dull, isn\'t it?');
-
     }
-
   };
-
   return tellEveryone;
-
 });
 
-
-
 // Como ya sabemos utilizar define usemos ahora `require` para poner en marcha
-
 //  nuestro programa. La firma de `require` es `(arrayOfDependencies, callback)`.
-
 require(['loudmouth'], function(loudmouth){
-
   loudmouth();
-
 });
 
-
-
 // Para hacer que este tutorial corra código, vamos a implementar una
-
 // versión muy básica (no-asíncrona) de AMD justo aquí:
-
 function define(name, deps, factory){
-
   // observa como son manejados los módulos sin dependencias
-
   define[name] = require(factory ? deps : [], factory || deps);
-
 }
 
-
-
 function require(deps, callback){
-
   var args = [];
-
   // primero recuperemos todas las dependencias que necesita
-
   // el llamado require
-
   for (var i = 0; i < deps.length; i++){
-
     args[i] = define[deps[i]];
-
   }
-
   // satisfacer todas las dependencias del callback
-
   return callback.apply(null, args);
-
 }
-
 // puedes ver este código en acción aquí: http://jsfiddle.net/qap949pd/
-
 ```
 
-
-
 ### Uso en el mundo real con require.js
 
-
-
 En contraste con el ejemplo introductorio, `require.js` (la librería AMD más popular) implementa la **A** de **AMD**, permitiéndote cargar los módulos y sus dependencias asincrónicamente via XHR:
 
-
-
 ```javascript
-
 /* file: app/main.js */
-
 require(['modules/someClass'], function(SomeClass){
-
   // el callback es diferido hasta que la dependencia sea cargada
-
   var thing = new SomeClass();
-
 });
-
 console.log('So here we are, waiting!'); // esto correrá primero
-
 ```
 
-
-
-Por convención, usualmente guardas un módulo en un fichero. `require.js` puede resolver los nombres de los módulos basados en rutas de archivo, de forma que no tienes que nombrar tus módulos, simplemente referenciarlos usando su ubicación. En el ejemplo `someClass` es asumido que se ubica en la carpeta `modules`, relativa a tu `baseUrl` configurada:
-
-
+Por convención, usualmente guardas un módulo en un fichero. `require.js` puede resolver los nombres de los módulos basados en rutas de archivo, de forma que no tienes que nombrar tus módulos, simplemente referenciarlos usando su ubicación. En el ejemplo `someClass` asumimos que se ubica en la carpeta `modules`, relativa a tu `baseUrl` configurada:
 
 * app/
-
   * main.js
-
   * modules/
-
     * someClass.js
-
     * someHelpers.js
-
     * ...
-
   * daos/
-
     * things.js
-
     * ...
 
-
-
 Esto significa que podemos definir `someClass` sin especificar su id de módulo:
 
-
-
 ```javascript
-
 /* file: app/modules/someClass.js */
-
 define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
-
   // definición de módulo, por supuesto, ocurrirá también asincrónicamente
-
   function SomeClass(){
-
     this.method = function(){/**/};
-
     // ...
-
   }
-
   return SomeClass;
-
 });
-
 ```
 
 Para alterar el comportamiento del mapeo de ruta usa `requirejs.config(configObj)` en tu `main.js`:
 
-
-
 ```javascript
-
 /* file: main.js */
-
 requirejs.config({
-
   baseUrl : 'app',
-
   paths : {
-
     // también puedes cargar módulos desde otras ubicaciones
-
     jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
-
     coolLibFromBower : '../bower_components/cool-lib/coollib'
-
   }
-
 });
-
 require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
-
   // un fichero `main` necesita llamar a require al menos una vez,
-
   // de otra forma jamás correrá el código
-
   coolLib.doFancyStuffWith(helpers.transform($('#foo')));
-
 });
-
 ```
-
 Las aplicaciones basadas en `require.js` usualmente tendrán un solo punto de entrada (`main.js`) que se pasa a la etiqueta del script `require.js` como un atributo de datos. Será cargado y ejecutado automáticamente al cargar la página:
 
-
-
 ```html
-
 <!DOCTYPE html>
-
 <html>
-
 <head>
-
   <title>Cien etiquetas de script? Nunca más!</title>
-
 </head>
-
 <body>
-
   <script src="require.js" data-main="app/main"></script>
-
 </body>
-
 </html>
-
 ```
 
-
-
 ### Optimizar todo un proyecto usando r.js
 
-
-
-Muchas personas prefiere usar AMD para la sana organización del código durante el desarrollo, pero todavía prefiere enviar para producción un solo fichero en vez de ejecutar cientos de XHRs en las cargas de página.
-
-
+Muchas personas prefieren usar AMD para la organización del código durante el desarrollo, pero quieren enviar para producción un solo fichero en vez de ejecutar cientos de XHRs en las cargas de página.
 
 `require.js` incluye un script llamado `r.js` (el que probablemente correrás en node.js, aunque Rhino también es soportado) que puede analizar el gráfico de dependencias de tu proyecto, y armar un solo fichero que contenga todos tus módulos (adecuadamente nombrados), minificado y listo para consumo.
 
-
-
 Instálalo usando `npm`:
-
 ```shell
-
 $ npm install requirejs -g
-
 ```
 
-
-
 Ahora puedes alimentarlo con un fichero de configuración:
-
 ```shell
-
 $ r.js -o app.build.js
-
 ```
 
-
-
 Para nuestro ejemplo anterior el archivo de configuración luciría así:
-
 ```javascript
-
 /* file : app.build.js */
-
 ({
-
-  name : 'main', // name of the entry point
-
-  out : 'main-built.js', // name of the file to write the output to
-
+  name : 'main', // nombre del punto de entrada
+  out : 'main-built.js', // nombre del fichero donde se escribirá la salida
   baseUrl : 'app',
-
   paths : {
-
-    // `empty:` tells r.js that this should still be loaded from the CDN, using
-
-    // the location specified in `main.js`
-
+    // `empty:` le dice a r.js que esto aún debe ser cargado desde el CDN, usando
+    // la ubicación especificada en `main.js`
     jquery : 'empty:',
-
     coolLibFromBower : '../bower_components/cool-lib/coollib'
-
   }
-
 })
-
 ```
 
-
-
 Para usar el fichero creado en producción, simplemente intercambia `data-main`:
-
 ```html
-
 <script src="require.js" data-main="app/main-built"></script>
-
 ```
 
-
-
 Un increíblemente detallado [resumen de opciones de generación](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponible en el repositorio de GitHub.
 
-
-
 ### Tópicos no cubiertos en este tutorial
-
 * [Cargador de plugins / transformaciones](http://requirejs.org/docs/plugins.html)
-
 * [Cargando y exportando estilos CommonJS](http://requirejs.org/docs/commonjs.html)
-
 * [Configuración avanzada](http://requirejs.org/docs/api.html#config)
-
 * [Configuración de Shim (cargando módulos no-AMD)](http://requirejs.org/docs/api.html#config-shim)
-
 * [Cargando y optimizando CSS con require.js](http://requirejs.org/docs/optimization.html#onecss)
-
 * [Usando almond.js para construcciones](https://github.com/jrburke/almond)
 
-
-
 ### Otras lecturas:
 
-
-
 * [Especificaciones oficiales](https://github.com/amdjs/amdjs-api/wiki/AMD)
-
 * [¿Por qué AMD?](http://requirejs.org/docs/whyamd.html)
-
 * [Definición Universal de Módulos](https://github.com/umdjs/umd)
 
-
-
 ### Implementaciones:
 
-
-
 * [require.js](http://requirejs.org)
-
 * [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
-
 * [cujo.js](http://cujojs.com/)
-
 * [curl.js](https://github.com/cujojs/curl)
-
 * [lsjs](https://github.com/zazl/lsjs)
-
 * [mmd](https://github.com/alexlawrence/mmd)
-- 
cgit v1.2.3


From a1217767d3dceb40dba35159abb523b233cf0005 Mon Sep 17 00:00:00 2001
From: Damaso Sanoja <narsil.dev@gmail.com>
Date: Sat, 17 Oct 2015 14:05:01 -0430
Subject: tmux spanish translation

---
 es-es/tmux-es.html.markdown | 253 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 253 insertions(+)
 create mode 100644 es-es/tmux-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/tmux-es.html.markdown b/es-es/tmux-es.html.markdown
new file mode 100644
index 00000000..a7354be1
--- /dev/null
+++ b/es-es/tmux-es.html.markdown
@@ -0,0 +1,253 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+filename: LearnTmux-es.txt
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+
+[tmux](http://tmux.sourceforge.net)
+es un terminal multiplexor: habilita la creación, acceso y control
+de múltiples terminales controlados desde una sola pantalla. tmux
+puede ser separado de una pantalla y continuar corriendo en el fondo
+y luego ser insertado nuevamente.
+
+
+```
+
+  tmux [command]     # Corre un comando
+                     # 'tmux' sin comandos creará una nueva sesión
+
+    new              # Crea una nueva sesión
+     -s "Session"    # Crea sesión con nombre
+     -n "Window"     # Crea ventana con nombre
+     -c "/dir"       # Comienza en el directorio destino 
+
+    attach           # Adjunta sesión última/disponible
+     -t "#"          # Adjunta sesión destino
+     -d              # Separa la sesión de otras instancias
+
+    ls               # Lista las sesiones abiertas
+     -a              # Lista todas las sesiones abiertas
+
+    lsw              # Lista las ventanas
+     -a              # Lista todas las ventanas
+     -s              # Lista todas las ventanas en la sesión
+
+    lsp              # Lista los páneles
+     -a              # Lista todos los páneles
+     -s              # Lista todos los páneles de la sesión
+     -t              # Lista los páneles de aplicación en el destino
+
+    kill-window      # Cierra la ventana actual
+     -t "#"          # Cierra la ventana destino
+     -a              # Cierra todas las ventanas
+     -a -t "#"       # Cierra todas las ventanas menos el destino
+
+    kill-session     # Cierra la sesión actual
+     -t "#"          # Cierra la sesión destino
+     -a              # Cierra todas las sesiones
+     -a -t "#"       # Cierra todas las sesiones menos el destino
+
+```
+
+
+### Atajos de Teclado
+
+El método para controlar una sesión adjunta tmux es mediante
+combinaciones de teclas llamadas teclas 'Prefijo'.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # combinación 'Prefijo' necesaria para usar atajos
+
+  (M-1) = Meta + 1 -o- Alt + 1
+----------------------------------------------------------------------
+
+  ?                  # Lista todos los atajos de teclado
+  :                  # Entra en la línea de comandos tmux
+  r                  # Fuerza el redibujado del cliente adjuntado
+  c                  # Crea una nueva ventana
+
+  !                  # Separa el panel actual fuera de la ventana.
+  %                  # Separa el panel actual en dos, izquierdo y derecho
+  "                  # Separa el panel actual en dos, superior e inferior
+
+  n                  # Cambia a la siguiente ventana
+  p                  # Cambia a la ventana previa
+  {                  # Intercambia el panel actual con el anterior
+  }                  # Intercambia el panel actual con el próximo
+
+  s                  # Selecciona una nueva sesión para el cliente adjuntado
+                     interactivamente
+  w                  # Elegir la ventana actual interactivamente
+  0 al 9             # Seleccionar ventanas 0 al 9
+
+  d                  # Separa el cliente actual
+  D                  # Elige un cliente para separar
+
+  &                  # Cierra la ventana actual
+  x                  # Cierra el panel actual
+
+  Up, Down           # Cambia al panel superior, inferior, izquierdo, o derecho
+  Left, Right
+
+  M-1 to M-5         # Organizar páneles:
+                       # 1) uniformes horizontales
+                       # 2) uniformes verticales
+                       # 3) principal horizontal
+                       # 4) principal vertical
+                       # 5) mozaico
+
+  C-Up, C-Down       # Redimensiona el panel actual en pasos de una celda
+  C-Left, C-Right
+
+  M-Up, M-Down       # Redimensiona el panel actual en pasos de cinco celdas
+  M-Left, M-Right
+
+```
+
+
+### Configurando ~/.tmux.conf
+
+tmux.conf puede usarse para establecer opciones automáticas al arrancar, parecido a como .vimrc o init.el hacen.
+
+```
+# Ejemplo de tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Habilita UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Fuera de pantalla/Historia límite
+set -g history-limit 2048
+
+# Comienzo de índice
+set -g base-index 1
+
+# Ratón
+set-option -g mouse-select-pane on
+
+# Forza recarga de fichero de configuración
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Atajos de teclado
+###########################################################################
+
+# Desvincula C-b como el prefijo por defecto
+unbind C-b
+
+# Establece el nuevo prefijo
+set-option -g prefix `
+
+# Regresa a la ventana previa cuando el prefijo es accionado dos veces
+bind C-a last-window
+bind ` last-window
+
+# Permite intercambiar C-a y ` usando F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Preferencias de atajos
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Moviéndose entre paneles con movimientos de teclas vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Ciclo/Intercambio de Ventana
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# División rápida de paneles
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Activar sesión mas interna (cuando se anida tmux) para enviar comandos
+bind a send-prefix
+
+
+### Temas
+###########################################################################
+
+# Paleta de Colores de la Barra de estado
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Paleta de Colores del Borde del Panel
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Paleta de Colores de Mensajes
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Paleta de Colores de la Ventana
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notificación
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Establece automáticamente títulos de ventanas
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Ajustes de barra de estado
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Muestra indicadores de rendimiento en barra de estado
+# Requiere https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Referencias
+
+[Tmux | Inicio](http://tmux.sourceforge.net)
+
+[Tmux Manual](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Mostrar CPU/MEM % en barra de estado](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
-- 
cgit v1.2.3


From b782df007bd961f55af0d9a57c75c7bf490ec445 Mon Sep 17 00:00:00 2001
From: Erick Bernal <ebernal@rubixware.com>
Date: Sun, 18 Oct 2015 23:25:01 -0500
Subject: Update and fix typos on ruby translation

---
 es-es/ruby-es.html.markdown | 247 +++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 222 insertions(+), 25 deletions(-)

(limited to 'es-es')

diff --git a/es-es/ruby-es.html.markdown b/es-es/ruby-es.html.markdown
index 66a5d0fe..d8b67fe7 100644
--- a/es-es/ruby-es.html.markdown
+++ b/es-es/ruby-es.html.markdown
@@ -5,8 +5,18 @@ contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
   - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
 translators:
     - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+    - ["Erick Bernal", "http://www.twitter.com/billowkib"]
 lang: es-es
 ---
 
@@ -33,6 +43,8 @@ Tu tampoco deberías
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
 
 # La aritmética es sólo azúcar sintáctico
 # para llamar un método de un objeto
@@ -55,8 +67,6 @@ false.class #=> FalseClass
 # Desigualdad
 1 != 1 #=> false
 2 != 1 #=> true
-!true  #=> false
-!false #=> true
 
 # Además de 'false', 'nil' es otro valor falso
 
@@ -70,14 +80,29 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
+# Operadores lógicos
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Existen versiones alternativas de los operadores lógicos con menor prioridad
+# Estos son usados como constructores controladores de flujo que encadenan
+# sentencias hasta que una de ellas retorne verdadero o falso
+
+# `has_otra_cosa` solo se llama si `has_algo` retorna verdadero.
+has_algo() and has_otra_cosa()
+# `registra_error` solo se llama si `has_algo` falla
+has_algo() or registra_error()
+
+
 # Los strings son objetos
 
 'Soy un string'.class #=> String
 "Soy un string también".class #=> String
 
-referente = "usar interpolacion de strings"
+referente = "usar interpolación de strings"
 "Yo puedo #{referente} usando strings de comillas dobles"
-#=> "Yo puedo usar interpolacion de strings usando strings de comillas dobles"
+#=> "Yo puedo usar interpolación de strings usando strings de comillas dobles"
 
 
 # Imprime a la salida estándar
@@ -119,15 +144,16 @@ status == :aprovado #=> false
 # Arreglos
 
 # Esto es un arreglo
-[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+arreglo = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
 # Arreglos pueden contener elementos de distintos tipos
 
-arreglo = [1, "hola", false] #=> => [1, "hola", false]
+[1, "hola", false] #=> => [1, "hola", false]
 
 # Arreglos pueden ser indexados
 # Desde el frente
 arreglo[0] #=> 1
+arreglo.first #=> 1
 arreglo[12] #=> nil
 
 # Tal como la aritmética, el acceso como variable[índice]
@@ -138,15 +164,25 @@ arreglo.[] 12 #=> nil
 
 # Desde el final
 arreglo[-1] #=> 5
+arreglo.last #=> 5
+
+# Con un índice de inicio y longitud
+arreglo[2, 3] #=> [3, 4, 5]
 
-# Con un índice de inicio y final
-arreglo[2, 4] #=> [3, 4, 5]
+# Invertir un arreglo
+a = [1, 2, 3]
+a.reverse! #=> [3, 2, 1]
 
 # O con rango
 arreglo[1..3] #=> [2, 3, 4]
 
 # Añade elementos a un arreglo así
 arreglo << 6 #=> [1, 2, 3, 4, 5, 6]
+# O así
+arreglo.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+#Verifica si un elemento ya existe en ese arreglo
+arreglo.include?(1) #=> true
 
 # Hashes son los diccionarios principales de Ruby con pares llave/valor.
 # Hashes se denotan con llaves:
@@ -161,17 +197,16 @@ hash['numero'] #=> 5
 # Preguntarle a un hash por una llave que no existe retorna 'nil':
 hash['nada aqui'] #=> nil
 
-# Itera sobre un hash con el método 'each':
-hash.each do |k, v|
-  puts "#{k} is #{v}"
-end
-
 # Desde Ruby 1.9, hay una sintaxis especial cuando se usa un símbolo como llave:
 
 nuevo_hash = { defcon: 3, accion: true}
 
 nuevo_hash.keys #=> [:defcon, :accion]
 
+# Verifica la existencia de llaves y valores en el hash
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+
 # Tip: Tanto los arreglos como los hashes son Enumerable (enumerables)
 # Comparten muchos métodos útiles tales como 'each', 'map', 'count', y más
 
@@ -194,9 +229,15 @@ end
 #=> iteracion 4
 #=> iteracion 5
 
-# Aunque
-# Nadie usa los ciclos `for`
-# Usa `each`, así:
+# SIN EMBARGO, nadie usa ciclos `for`
+# En su lugar debes usar el método "each" y pasarle un block (bloque).
+# Un bloque es un fragmento código que puedes pasar a métodos como `each`.
+# Es símilar a las funciones lambda, funciones anónimas o `closures` en otros
+# lenguajes de programación.
+#
+# El método `each` de un Range (rango) ejecuta el bloque una vez por cada elemento.
+# Al bloque se le pasa un contador como parametro.
+# Usar el método `each` con un bloque se ve así:
 
 (1..5).each do |contador|
   puts "iteracion #{contador}"
@@ -207,10 +248,27 @@ end
 #=> iteracion 4
 #=> iteracion 5
 
-counter = 1
-while counter <= 5 do
-  puts "iteracion #{counter}"
-  counter += 1
+# También puedes envolver el bloque entre llaves:
+(1..5).each { |counter| puts "iteración #{contador}" }
+
+#El contenido de las estructuras de datos en ruby puede ser iterado usando `each`.
+arreglo.each do |elemento|
+  puts "#{elemento} es parte del arreglo"
+end
+hash.each do |llave, valor|
+  puts "#{llave} es #{valor}"
+end
+
+# Si aún necesitas un índice puedes usar "each_with_index" y definir una variable
+# índice.
+arreglo.each_with_index do |element, index|
+  puts "#{element} tiene la posición #{index} en el arreglo"
+end
+
+contador = 1
+while contador <= 5 do
+  puts "iteracion #{contador}"
+  contador += 1
 end
 #=> iteracion 1
 #=> iteracion 2
@@ -218,6 +276,19 @@ end
 #=> iteracion 4
 #=> iteracion 5
 
+# Hay una gran variedad de otras funciones iterativas útiles en Ruby,
+# por ejemplo `map`, `reduce`,  `inject`, entre otras. Map, por ejemplo,
+# toma el arreglo sobre el cuál está iterando, le hace cambios
+# definidos en el bloque, y retorna un arreglo completamente nuevo.
+arreglo = [1,2,3,4,5]
+duplicado = array.map do |elemento|
+  elemento * 2
+end
+puts duplicado
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
 nota = 'B'
 
 case nota
@@ -234,6 +305,34 @@ when 'F'
 else
   puts "Sistema alternativo de notas, ¿eh?"
 end
+#=> "Mejor suerte para la proxima"
+
+# Los casos también pueden usar rangos
+nota = 82
+
+case nota
+when 90..100
+  puts 'Excelente!'
+when 80..100
+  puts 'Buen trabajo'
+else
+  puts '¡Reprobaste!'
+end
+#=> "Buen trabajo"
+
+# Manejo de excepciones
+begin
+  # código que podría causar excepción
+  raise NoMemoryError, 'Se te acabó la memoria'
+rescue NoMemoryError => variable_de_excepcion
+  puts 'El error NoMemoryError ocurrió', variable_de_excepcion
+rescue RuntimeError => otra_variable_de_excepcion
+  puts 'El error RuntimeError ocurrió'
+else
+  puts 'Esto se ejecuta si ningun error ocurrió'
+ensure
+  puts 'Este código siempre se ejecuta, sin importar que'
+end
 
 # Funciones
 
@@ -244,7 +343,7 @@ end
 # Funciones (y todos los bloques) implícitamente retornan el valor de la última instrucción
 doble(2) #=> 4
 
-# Paréntesis son opcionales cuando el resultado es ambiguo
+# Paréntesis son opcionales cuando el resultado no es ambiguo
 doble 3 #=> 6
 
 doble doble 3 #=> 12
@@ -259,7 +358,7 @@ suma 3, 4 #=> 7
 suma suma(3,4), 5 #=> 12
 
 # yield
-# Todos los métodos tienen un parámetro de bloqueo opcional e implícitp
+# Todos los métodos tienen un parámetro bloque opcional e implícito
 # puede llamarse con la palabra clave 'yield'
 
 def alrededor
@@ -274,6 +373,17 @@ alrededor { puts 'hola mundo' }
 # hola mundo
 # }
 
+# Puedes pasar un bloque a una función
+# '&' representa una referencia a un bloque
+def visitantes(&bloque)
+  bloque.call
+end
+
+# Puedes pasar una lista de argumentos, que serán convertidos en un arreglo
+# Para eso sirve el operador ('*')
+def visitantes(*arreglo)
+  arreglo.each { |visitante| puts visitante }
+end
 
 # Define una clase con la palabra clave 'class'
 class Humano
@@ -299,16 +409,26 @@ class Humano
     @nombre
   end
 
+  # La funcionalidad anterior puede ser encapsulada usando el método attr_accessor
+  # de la siguiente manera
+
+  attr_accessor :name
+
+  # Los métodos de tipo getter y setter también se pueden crear de manera individual
+  # de la siguiente manera
+
+  attr_reader :name
+  attr_writer :name
+
   # Un método de clase usa 'self' (sí mismo) para distinguirse de métodos de instancia.
   # Sólo puede ser llamado en la clase, no por una instancia.
   def self.decir(mensaje)
-    puts "#{mensaje}"
+    puts mensaje
   end
 
   def especie
     @@especie
   end
-
 end
 
 
@@ -328,6 +448,23 @@ dwight.nombre #=> "Dwight K. Schrute"
 # Llama el método de clase
 Humano.decir("Hi") #=> "Hi"
 
+# El alcance de las variables es definido por la manera en que las nombramos.
+# Las variables que inician con $ tienen un alcance global
+$var = "Soy una variable global"
+defined? $var #=> "global-variable"
+
+# Las variables que empiezan con @ tienen un alcance de instancia
+@var = "Soy una variable de instancia"
+defined? @var #=> "instance-variable"
+
+# Variables que empiezan con @@ tienen un alcance de clase
+@@var = "Soy una variable de clase"
+defined? @@var #=> "class variable"
+
+# Las variables que empiezan con letra mayuscula son constantes
+Var = "Soy una constante"
+defined? Var #=> "constant"
+
 # Las clases también son un objeto en ruby. Por lo cual, las clases también pueden tener variables de instancia.
 # Variables de clase son compartidas a través de la clase y todos sus descendientes.
 
@@ -371,7 +508,67 @@ end
 class Doctor < Humano
 end
 
-Human.bar # 0
+Humano.bar # 0
 Doctor.bar # nil
 
+module ModuloEjemplo
+  def foo
+    'foo'
+  end
+end
+
+# Al incluir un módulo sus métodos se comparten con las instancias de la clase
+# Al extender un módulo sus métodos se comparten con la clase misma
+
+class Persona
+  include ModuloEjemplo
+end
+
+class Libro
+  extend ModuloEjemplo
+end
+
+Persona.foo     # => NoMethodError: undefined method `foo' for Persona:Class
+Persona.new.foo # => 'foo'
+Libro.foo       # => 'foo'
+Libro.new.foo   # => NoMethodError: undefined method `foo'
+
+# Las llamadas de retorno (callbacks) son ejecutadas cuando se incluye o
+# extiende un módulo
+module EjemploConcern
+  def self.incluido(base)
+    base.extend(MetodosClase)
+    base.send(:include, MetodosInstancia)
+  end
+
+  module MetodosClase
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodosInstancia
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Algo
+  include EjemploConcern
+end
+
+Algo.bar #=> 'bar'
+Algo.qux #=> NoMethodError: undefined method `qux'
+Algo.new.bar # => NoMethodError: undefined method `bar'
+Algo.new.qux # => 'qux'
 ```
+
+## Recursos adicionales
+- [Aprende Ruby Mediante Ejemplo con Ejercicios](http://www.learneroo.com/modules/61/nodes/338) - Una variante de
+esta referencia con ejercicios en navegador.
+- [Documentación Oficial](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby desde otros lenguajes](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programando Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una
+[edición antigua](http://ruby-doc.com/docs/ProgrammingRuby/) gratuita disponible en línea.
+- [Guía de estilo de Ruby](https://github.com/bbatsov/ruby-style-guide) - Guía de estilo creada por la comunidad.
-- 
cgit v1.2.3


From 8323f873c4079132d92e5d4a9f355489ea38abca Mon Sep 17 00:00:00 2001
From: Diego Ponce <diegoponce@outlook.com>
Date: Sun, 25 Oct 2015 13:38:15 -0600
Subject: Fix typos

---
 es-es/markdown-es.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index d90e3eb5..bc481df7 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -11,7 +11,7 @@ lang: es-es
 Markdown fue creado por John Gruber en 2004. Su propósito es ser una sintaxis fácil de leer y escribir que se convierta
 fácilmente a HTML (y, actualmente, otros formatos también).
 
-¡Denme todo la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests!
+¡Denme toda la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests!
 
 
 ```markdown
@@ -44,7 +44,7 @@ Esto es un h2
 -------------
 
 <!-- Estilos para texto plano -->
-<!-- El texto puede ser fácilmente estilizaedo con italicas, negritas o tachado 
+<!-- El texto puede ser fácilmente estilizado con italicas, negritas o tachado 
 usando markdown -->
 
 *Este texto está en itálicas.*
@@ -62,7 +62,7 @@ Markdown en Github, también tenemos: -->
 
 ~~Este texto está tachado.~~
 
-<!-- Los párrafos son una o múltuples líneas de texto adyacentes separadas por 
+<!-- Los párrafos son una o múltiples líneas de texto adyacentes separadas por 
 una o múltiples líneas en blanco-->
 
 Este es un párrafo. Estoy escribiendo un párrafo, ¿No es divertido?
-- 
cgit v1.2.3