es: orthography corrections

README-es.md

@@ -19,7 +19,7 @@
 
 ![curl -s 'https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md' | egrep -o '`\w+`' | tr -d '`' | cowsay -W50](cowsay.png)
 
-La fluidez en el terminal es una destreza a menudo abandonada y considerada arcaica, pero esta mejora su flexibilidad y productividad como ingeniero en formas obvia y sutil. Esta es una selección de notas y consejos al usar el terminal que encontré útiles al trabajar en Linux. Algunos consejos son elementales y algunos bastante específicos, sofisticados u oscuros. Esta página no es larga, pero si usa y recuerda todos los puntos aquí mostrados, ustedes sabrán un montón.
+La fluidez en el terminal es una destreza a menudo abandonada y considerada arcaica, pero esta mejora su flexibilidad y productividad como ingeniero en formas obvia y sutil. Esta es una selección de notas y consejos al usar el terminal que encontré útiles al trabajar en Linux. Algunos consejos son elementales y algunos bastante específicos, sofisticados u oscuros. Esta página no es larga, pero sí usa y recuerda todos los puntos aquí mostrados, ustedes sabrán un montón.
 
 Gran parte está en
 [originally](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands)
@@ -39,17 +39,17 @@ Alcance:
 
 Notas:
 
-- Para mantener esto en una página, el contenido esta incluido implícitamente por referencia. Usted es suficientemente inteligente para ver profundamente los detalles en otros lugares, cuando conoces la idea o comando en Google. Usar `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (según proceda) para instalar los nuevos programas.
+- Para mantener esto en una página, el contenido está incluido implícitamente por referencia. Usted es suficientemente inteligente para ver profundamente los detalles en otros lugares, cuando conoces la idea o comando en Google. Usar `apt-get`/`yum`/`dnf`/`pacman`/`pip`/`brew` (según proceda) para instalar los nuevos programas.
 - Usar [Explainshell](http://explainshell.com/) para obtener detalles de ayuda sobre que comandos, opciones, pipes, etc.
 
 
 ## Fundamentos
 
-- Aprenda conocimientos básicos de Bash, de hecho, escriba `man bash` y al menos échele un vistazo a toda la cosa. Es bastante fácil de seguir y no es tan largo. Alternar entre shells puede ser agradable, pero Bash es poderoso y siempre esta disponible (conocer *solo* zsh, fish, etc., aunque resulte tentador en tu propia laptop, los restringe en muchas situaciones, tales como el uso de servidores existentes).
+- Aprenda conocimientos básicos de Bash, de hecho, escriba `man bash` y al menos échele un vistazo a toda la cosa. Es bastante fácil de seguir y no es tan largo. Alternar entre shells puede ser agradable, pero Bash es poderoso y siempre está disponible (conocer *solo* zsh, fish, etc., aunque resulte tentador en tu propia laptop, los restringe en muchas situaciones, tales como el uso de servidores existentes).
 
 - Aprenda bien al menos un editor de texto, idealmente Vim (`vi`), como no hay realmente una competencia para la edición aleatoria en un terminal (incluso si usa Emacs, un gran IDE, o un editor alternativo (hipster) moderno la mayor parte del tiempo).
 
-- Conozca como leer la documentación con `man` (Para curiosos, `man man` lista las secciones enumeradas, ej. 1 es comandos "regulares", 5 son archivos/convenciones, y 8 are para administración). En en las páginas de man `apropos`. Conozca que alguno de los comandos no son ejecutables, pero son Bash builtins, y que puede obtener ayuda sobre ellos con `help` y `help -d`.
+- Conozca como leer la documentación con `man` (Para curiosos, `man man` lista las secciones enumeradas, ej. 1 es comandos "regulares", 5 son archivos/convenciones, y 8 para administración). En en las páginas de man `apropos`. Conozca que alguno de los comandos no son ejecutables, pero son Bash builtins, y que puede obtener ayuda sobre ellos con `help` y `help -d`.
 
 - Aprenda sobre redirección de salida >, entrada < y pipes utilizando `|`. Conozca que `>` sobrescribe el archivo de salida y `>>` añade. Aprenda sobre stdout y stderr.
 
@@ -72,17 +72,17 @@ Notas:
 
 - En Bash, se usa **Tab** para completar los argumentos y **ctrl-r** para buscar, a través del historial de comandos.
 
-- En Bash, se usa **ctrl-w** para borrar la última palabra, y **ctrl-u** para borrar todo el camino hasta el inicio de la línea. Se usa **alt-b** y **alt-f** para moverse entre letras, **ctrl-a** para mover el cursor al principio de la línea,  **ctrl-e** para mover el cursor al final de la línea,  **ctrl-k** para eliminar hasta el final de la línea, **ctrl-l** para limpiar la panatalla. Ver `man readline` para todos los atajos de teclado por defecto en Bash. Son una gran cantidad. Por ejemplo **alt-.** realiza un ciclo a través de los comandos previos, y **alt-*** expande un glob.
+- En Bash, se usa **ctrl-w** para borrar la última palabra, y **ctrl-u** para borrar todo el camino hasta el inicio de la línea. Se usa **alt-b** y **alt-f** para moverse entre letras, **ctrl-a** para mover el cursor al principio de la línea,  **ctrl-e** para mover el cursor al final de la línea,  **ctrl-k** para eliminar hasta el final de la línea, **ctrl-l** para limpiar la pantalla. Ver `man readline` para todos los atajos de teclado por defecto en Bash. Son una gran cantidad. Por ejemplo **alt-.** realiza un ciclo a través de los comandos previos, y **alt-*** expande un glob.
 
 - Alternativamente, si amas los atajos de teclado vi-style, usa `set -o vi`.
 
-- Para ver los últimos comandos, `history`. También existen abreviaciones, tales como, `!$` (último argumento) y `!!` último comando, auque sin facílmente remplazados con **ctrl-r** y **alt-.**.
+- Para ver los últimos comandos, `history`. También existen abreviaciones, tales como, `!$` (último argumento) y `!!` último comando, aunque son fácilmente remplazados con **ctrl-r** y **alt-.**.
 
-- Para volver al diretorio de trabajo previo: `cd -`
+- Para volver al directorio de trabajo previo: `cd -`
 
-- Si estas a mitad de camino de escritura de un comando pero cambias de opinión, presiona **alt-#** para agregar un `#` al principio y lo agrega como comentario (o usar **ctrl-a**, **#**, **enter**). Para que puedas entonces regresar a este luego vía comando `history`.
+- Si estás a mitad de camino de escritura de un comando pero cambias de opinión, presiona **alt-#** para agregar un `#` al principio y lo agrega como comentario (o usar **ctrl-a**, **#**, **enter**). Para que puedas entonces regresar a este luego vía comando `history`.
 
-- Se usa `xargs` (or `parallel`). Esto es muy poderoso. Nota: puedes controlar muchos items ejecutados por línea (`-L`), tamabién es conocido como paralelismo (`-P`). Si no estas seguro, este puede ser el camino correcto, usa `xargs echo` primero. También, `-I{}` es comodo. Ejemplos:
+- Se usa `xargs` (or `parallel`). Esto es muy poderoso. Nota: puedes controlar muchos elementos ejecutados por línea (`-L`), también es conocido como paralelismo (`-P`). Si no estas seguro, este puede ser el camino correcto, usa `xargs echo` primero. También, `-I{}` es cómodo. Ejemplos:
 ```bash
       find . -name '*.py' | xargs grep some_function
       cat hosts | xargs -I{} ssh root@{} hostname
@@ -96,7 +96,7 @@ Notas:
 
 - Usa `nohup` o `disown` si quieres mantener un proceso de fondo corriendo para siempre.
 
-- Verifica que procesos esta escuchando via `netstat -lntp` o `ss -plat` (para TCP; agrega `-u` para UDP).
+- Verifica que procesos están escuchando vía `netstat -lntp` o `ss -plat` (para TCP; agrega `-u` para UDP).
 
 - Consulta también `lsof` para abrir sockets y archivos.
 
@@ -104,14 +104,14 @@ Notas:
 
 - En scripts Bash, usa `set -x` para depurar la salida. Utiliza el modo estricto cuando se posible. Utiliza `set -e` para abortar en errores. Utiliza `set -o pipefail` también, para ser estrictos sobre los errores (aunque este tema es un poco delicado). Para scripts más complejos, también se puede utilizar `trap`.
 
-- En scripts Bash, subshells (escritos con parentesís) son maneras convenientes para agrupar los comandos. Un ejemplo común es para moverse temporalmente hacia un directorio diferente del de trabajo, Ej.
+- En scripts Bash, subshells (escritos con paréntesis) son maneras convenientes para agrupar los comandos. Un ejemplo común es para moverse temporalmente hacia un directorio diferente del de trabajo, Ej.
 ```bash
       # do something in current dir
       (cd /some/other/dir && other-command)
       # continue in original dir
 ```
 
-- En Bash, considere que hay muchas formas de expansión de variables. Verificar la existencia de una variable: `${name:?error message}`. Por ejemplo, si un script Bash requiere un único argumento, solo escriba `input_file=${1:?usage: $0 input_file}`. Expansión arítmetica: `i=$(( (i + 1) % 5 ))`. Secuencias: `{1..10}`. Reducción de strings: `${var%suffix}` y `${var#prefix}`. Por ejemplo si `var=foo.pdf`, entonces `echo ${var%.pdf}.txt` imprime `foo.txt`.
+- En Bash, considere que hay muchas formas de expansión de variables. Verificar la existencia de una variable: `${name:?error message}`. Por ejemplo, si un script Bash requiere un único argumento, solo escriba `input_file=${1:?usage: $0 input_file}`. Expansión aritmética: `i=$(( (i + 1) % 5 ))`. Secuencias: `{1..10}`. Reducción de strings: `${var%suffix}` y `${var#prefix}`. Por ejemplo si `var=foo.pdf`, entonces `echo ${var%.pdf}.txt` imprime `foo.txt`.
 
 - La salida de un comando puede ser tratado como un archivo, vía `<(some command)`. Por ejemplo, compare local `/etc/hosts` con uno remoto:
 ```sh
@@ -120,15 +120,15 @@ Notas:
 
 - Conocer acerca "here documents" en Bash, así también `cat <<EOF ...`.
 
-- En Bash, redireccionar salida estándar y error estándar, via: `some-command >logfile 2>&1`. Frecuentemente, para garantizar que un comando no haya dejado abierto un archivo para controlar la entrada estándar vinculada al terminal en el que te encuentras y también como buena practica puedes agregar `</dev/null`.
+- En Bash, redireccionar salida estándar y error estándar, via: `some-command >logfile 2>&1`. Frecuentemente, para garantizar que un comando no haya dejado abierto un archivo para controlar la entrada estándar vinculada al terminal en el que te encuentras y también como buena práctica puedes agregar `</dev/null`.
 
 - Use `man ascii` para una buena tabla ASCII, con valores hexadecimal y decimales. Para información de codificación general, `man unicode`, `man utf-8`, y `man latin1` son de utilidad.
 
 - Use `screen` o [`tmux`](https://tmux.github.io/) para multiplexar la pantalla, especialmente útil en sesiones ss remotas y para desconectar y reconectar a una sesión. Una alternativa más minimalista para persistencia de la sesión solo sería `dtach`.
 
-- En ssh, conocer como hacer un port tunnel con `-L` o `-D` (y de vez en cuando `-R`) es útil, Ej. para acceder sitio web desde un servidor remoto.
+- En ssh, conocer cómo hacer un port tunnel con `-L` o `-D` (y de vez en cuando `-R`) es útil, Ej. para acceder sitio web desde un servidor remoto.
 
-- esto puede ser útil para hacer algunas optimizaciones para su configuración ssh; por ejemplo, Este, `~/.ssh/config` contiene la configuracion para evitar desconexiones en ciertos entornos de red, utiliza la comprensión (cual es útil con scp sobre conexiones con un ancho de banda pequeña), y la multiplexíon de los canales para el mismo servidor con un archivo de control local:
+- esto puede ser útil para hacer algunas optimizaciones para su configuración ssh; por ejemplo, Este, `~/.ssh/config` contiene la configuración para evitar desconexiones en ciertos entornos de red, utiliza la compresión (cual es útil con scp sobre conexiones con un ancho de banda pequeña), y la multiplexión de los canales para el mismo servidor con un archivo de control local:
 ```
       TCPKeepAlive=yes
       ServerAliveInterval=15
@@ -158,11 +158,11 @@ Notas:
 
 ## Procesamiento de archivos y datos
 
-- Para localizar un archivo por nombre en el directorio actual, `find . -iname '*something*'` (o similar). Para encontrar un archivo en cualquier lado por nombre, usar `locate something` (pero tenga en mente `updatedb` quizas no haya indexado recientement los archivos creados).
+- Para localizar un archivo por nombre en el directorio actual, `find . -iname '*something*'` (o similar). Para encontrar un archivo en cualquier lado por nombre, usar `locate something` (pero tenga en mente `updatedb` quizás no haya indexado recientemente los archivos creados).
 
 - Por lo general buscar por la fuente o archivos de datos (más avanzado que `grep -r`), usar [`ag`](https://github.com/ggreer/the_silver_searcher).
 
-- Para convertir HTML a text: `lynx -dump -stdin`
+- Para convertir HTML a texto: `lynx -dump -stdin`
 
 - Para Markdown, HTML, y todos los tipos de conversión de documentos, probar [`pandoc`](http://pandoc.org/).
 
@@ -174,19 +174,19 @@ Notas:
 
 - Para Amazon S3, [`s3cmd`](https://github.com/s3tools/s3cmd) es conveniente y [`s4cmd`](https://github.com/bloomreach/s4cmd) es el mas rápido. Hecho por Amazon [`aws`](https://github.com/aws/aws-cli) es esencial para otras tareas relacionadas al AWS.
 
-- Conocer acerca `sort` y `uniq`, incluyendo opciones de uniq `-u` y `-d` -- ver unas lineas mas abajo.
+- Conocer acerca `sort` y `uniq`, incluyendo opciones de uniq `-u` y `-d` -- ver unas líneas más abajo.
 
 - Conocer acerca `cut`, `paste` y `join` para manipular archivos de texto. Muchas personas usan `cut` pero se olvidan acerca de `join`.
 
-- Conocer acerca `wc` para contar nuevas líneas (`-l`), caractéres (`-m`), palabras (`-w`) y bytes (`-c`).
+- Conocer acerca `wc` para contar nuevas líneas (`-l`), caracteres (`-m`), palabras (`-w`) y bytes (`-c`).
 
 - Conocer acerca `tee` para copiar desde el stdin hacia un archivo y también hacia el stdout, así `ls -al | tee file.txt`.
 
-- Conocer que `locale` afecta muchas herramientas de línea de comando en forma delicada, incluyendo el orden del ordenamiento (compaginación) y rendimiento. La mayoría de las instalaciones de Linux configuran `LANG` u otras variables de localización para la configuración local como US English. Pero esté alerta, el ordenamiento puede cambiar si cambia la localización. Y también las rutinas i18n pueden hacer que `sort` u otros comandos se ejecuten **muchas veces** más lentos. En algunas situaciones (tales como la realización de operaciones u operaciones singulares debajo) puede de forma segura ignorar las turinas lentas i18n por completo y utilizar el sort tradicional basado en byte, usando `export LC_ALL=C`.
+- Conocer que `locale` afecta muchas herramientas de línea de comando en forma delicada, incluyendo el orden del ordenamiento (compaginación) y rendimiento. La mayoría de las instalaciones de Linux configuran `LANG` u otras variables de localización para la configuración local como US English. Pero esté alerta, el ordenamiento puede cambiar si cambia la localización. Y también las rutinas i18n pueden hacer que `sort` u otros comandos se ejecuten **muchas veces** más lentos. En algunas situaciones (tales como la realización de operaciones u operaciones singulares debajo) puede de forma segura ignorar las rutinas lentas i18n por completo y utilizar el sort tradicional basado en byte, usando `export LC_ALL=C`.
 
 - Conozca aspectos básicos de `awk` y `sed` para manejo de datos. Por ejemplo, sumar todos lo números en la tercera columna de un archivo de texto: `awk '{ x += $3 } END { print x }'`. Esto es probablemente 3X más rápido y 3X más corto que su equivalente en Python.
 
-- Para remplazar todas las ocurrencias de un string en su lugar, en uno o más archivos:
+- Para reemplazar todas las ocurrencias de un string en su lugar, en uno o más archivos:
 ```sh
       perl -pi.bak -e 's/old-string/new-string/g' my-files-*.txt
 ```
@@ -201,7 +201,7 @@ Notas:
 
 - Usar `shuf` para mezclar o seleccionar líneas aleatorias desde un archivo.
 
-- Conozca las opciones de `sort`. Para números, use `-n`, o `-h` para manipulación de números humanamente leíbles (Ej. desde `du -h`). Conozca el trabajo principal de (`-t` y `-k`). En particular, este atento que lo necesitara para escribir`-k1,1` para ordenar por solo el primer campo; `-k1` significa ordenar de acuerdo a toda la línea. Orden estable (`sort -s`) puede ser útil. Por ejemplo, para organizar el primer por el campo 2, entonces secundariamente hacerlo por el campo 1, Puedes usar `sort -k1,1 | sort -s -k2,2`.
+- Conozca las opciones de `sort`. Para números, use `-n`, o `-h` para manipulación de números humanamente leíbles (Ej. desde `du -h`). Conozca el trabajo principal de (`-t` y `-k`). En particular, este atento que lo necesitará para escribir`-k1,1` para ordenar por solo el primer campo; `-k1` significa ordenar de acuerdo a toda la línea. Orden estable (`sort -s`) puede ser útil. Por ejemplo, para organizar el primer por el campo 2, entonces secundariamente hacerlo por el campo 1, Puedes usar `sort -k1,1 | sort -s -k2,2`.
 
 - Si necesitas siempre escribir un tab literal en una línea de comandos en Bash (Ej. para el argumento -t de ordenar), presione **ctrl-v** **[Tab]** o escriba `$'\t'` (El último es mejor porque puedes copiarlo/pegarlo).
 
@@ -213,12 +213,12 @@ Notas:
 
 - Para diffs binaria (delta compression), usar `xdelta3`.
 
-- Para convertir la codificación del texto, probar `iconv`. O `uconv` para el uso avanzado; este soporta este soporta algunos elementos Unicode avanzados. Por ejemplo, este coloca en minúsculas y remueve todos los acentos (por expanción y colocandolos a ellos):
+- Para convertir la codificación del texto, probar `iconv`. O `uconv` para el uso avanzado; este soporta este soporta algunos elementos Unicode avanzados. Por ejemplo, este coloca en minúsculas y remueve todos los acentos (por expanción y colocándolos a ellos):
 ```sh
       uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt
 ```
 
-- Para dividir archivos en multiples partes, consultar `split` (para dividir por tamaño) y `csplit` (para dividir por un patrón).
+- Para dividir archivos en múltiples partes, consultar `split` (para dividir por tamaño) y `csplit` (para dividir por un patrón).
 
 - Usar `zless`, `zmore`, `zcat`, y `zgrep` para operar sobre archivos comprimidos.
 
@@ -227,9 +227,9 @@ Notas:
 
 - Para depuración web, `curl` y `curl -I` son prácticos, o sus equivalentes `wget`, o el más moderno [`httpie`](https://github.com/jakubroztocil/httpie).
 
-- Para el estado del disco/cpu/red, usar `iostat`, `netstat`, `top` (o el mejor `htop`), y (especialmente) `dstat`. Bueno para recibir una idea rápida de lo que esta pasando en tu sistema.
+- Para el estado del disco/cpu/red, usar `iostat`, `netstat`, `top` (o el mejor `htop`), y (especialmente) `dstat`. Bueno para recibir una idea rápida de lo que está pasando en tu sistema.
 
-- Para una resumen en mayor profundidad, usar [`glances`](https://github.com/nicolargo/glances). Este se presenta con varios niveles de estadística en un solo terminal. Muy útil para una verificación rápida de vaios subsistemas.
+- Para una resumen en mayor profundidad, usar [`glances`](https://github.com/nicolargo/glances). Este se presenta con varios niveles de estadística en un solo terminal. Muy útil para una verificación rápida de varios subsistemas.
 
 - Para conocer el estado de la memoria, ejecutar y entender la salida de `free` y `vmstat`. En particular, tener en cuenta el valor "cached" es memoria mantenida por el kernel Linux como un archivo de cache, entonces efectivamente cuenta como valor para "free".
 
@@ -237,15 +237,15 @@ Notas:
 
 - Usar `mtr` como un mejor traceroute, para identificar los problemas en la red.
 
-- Para mirara porque el disco esta lleno, `ncdu` ahorra tiempo sobre los comandos usual como `du -sh *`.
+- Para mirara porque el disco está lleno, `ncdu` ahorra tiempo sobre los comandos usual como `du -sh *`.
 
-- Para encontrar cual socket o proceso  esta utilizando el ancho de banda, prueba `iftop` o `nethogs`.
+- Para encontrar cual socket o proceso está utilizando el ancho de banda, prueba `iftop` o `nethogs`.
 
 - La herramienta `ab` (viene con Apache) es útil para una verificación rápida y sucia del rendimiento del servidor web. Para pruebas de carga más complejas, prueba `siege`.
 
 - Para depuración de redes más serias, `wireshark`, `tshark`, o `ngrep`.
 
-- Conozca acerca `strace` y `ltrace`. Estas son de utilidad si un programa esta fallando, guindando, o estrellando, y no conoces por qué?, o si quieres tener una idea general del rendimiento. Note la opción de elaboración de perfiles (`-c`), y la habilidad de adjuntar a un proceso en ejecución (`-p`).
+- Conozca acerca `strace` y `ltrace`. Estas son de utilidad si un programa está fallando, guindando, o estrellando, y no conoces por qué?, o si quieres tener una idea general del rendimiento. Note la opción de elaboración de perfiles (`-c`), y la habilidad de adjuntar a un proceso en ejecución (`-p`).
 
 - Conozca acerca `ldd` para verificar librerías compartidas etc.
 
@@ -253,7 +253,7 @@ Notas:
 
 - Usar `/proc`. Este es extraordinariamente útil algunas veces cuando hay problemas de depuración en vivo. Ejemplos: `/proc/cpuinfo`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps`.
 
-- Cuando se depura porque algo salio más en el pasado, `sar` puede ser muy útil. Este muestra la estadistica historica en CPU, memoria, red, etc.
+- Cuando se depura porque algo salió más en el pasado, `sar` puede ser muy útil. Este muestra la estadística histórica en CPU, memoria, red, etc.
 
 - Para sistemas y análisis de rendimiento de mayor profundidad, ver `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), y [`sysdig`](https://github.com/draios/sysdig).
 
@@ -266,27 +266,27 @@ Notas:
 
 Algunos ejemplos de comandos reunidos:
 
-- Este es notablemente útil en ocasiones que hay que realizar intersección, unión, y diferencia de archivos de texto vía `sort`/`uniq`. Considere `a` y `b` como archivos de texto que son únicos. Esto es rápido, y trabaja con archivos de tamaño arbitrario, hasta varios gigabytes. (Sort no esta limitado por la memoria, aunque quizás necesites utilizar la opción `-T` si `/tmp` esta en una pequeña partición raíz.) Ver también la nota acerca `LC_ALL` y las opciones de `sort`, `-u` (dejado de lado para clarificar mas abajo).
+- Este es notablemente útil en ocasiones que hay que realizar intersección, unión, y diferencia de archivos de texto vía `sort`/`uniq`. Considere `a` y `b` como archivos de texto que son únicos. Esto es rápido, y trabaja con archivos de tamaño arbitrario, hasta varios gigabytes. (Sort no está limitado por la memoria, aunque quizás necesites utilizar la opción `-T` si `/tmp` está en una pequeña partición raíz.) Ver también la nota acerca `LC_ALL` y las opciones de `sort`, `-u` (dejado de lado para clarificar más abajo).
 ```sh
       cat a b | sort | uniq > c   # c is a union b
       cat a b | sort | uniq -d > c   # c is a intersect b
       cat a b b | sort | uniq -u > c   # c is set difference a - b
 ```
 
-- Usar `grep . *` para visualmente examinar todo el contenido de todos los archivos de un directorio, Ej. para directorios llenos con parametros de configuración, como `/sys`, `/proc`, `/etc`.
+- Usar `grep . *` para visualmente examinar todo el contenido de todos los archivos de un directorio, Ej. para directorios llenos con parámetros de configuración, como `/sys`, `/proc`, `/etc`.
 
 
-- Sumar todos os números en la tercera columna de un archivo de texto (esto es probablemente 3X más rápido 3X menor código que el equivalente en Python):
+- Sumar todos los números en la tercera columna de un archivo de texto (esto es probablemente 3X más rápido 3X menor código que el equivalente en Python):
 ```sh
       awk '{ x += $3 } END { print x }' myfile
 ```
 
-- Si quiere ver tamaños/fechas en un árbol de archivos, esto es como hacer recursivo `ls -l` pero es mas facil de leer que `ls -lR`:
+- Si quiere ver tamaños/fechas en un árbol de archivos, esto es como hacer recursivo `ls -l` pero es más fácil de leer que `ls -lR`:
 ```sh
       find . -type f -ls
 ```
 
-- Digamos que tiene un archivo de texto, como un log de un servidor web, y un cierto valor comienza a aparecer en algunas líneas, tales como un parametro `acct_id` que esta presente en el URL. Si quieres un recuento de cuantas peticiones ""request hay por cada `acct_id`:
+- Digamos que tiene un archivo de texto, como un log de un servidor web, y un cierto valor comienza a aparecer en algunas líneas, tales como un parámetro `acct_id` que está presente en el URL. Si quieres un recuento de cuantas peticiones ""request hay por cada `acct_id`:
 ```sh
       cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn
 ```
@@ -307,7 +307,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `expr`: ejecuta operaciones aritméticas o booleanas o evalúa expresiones regulares
 
-- `m4`: macro procesador sencillo
+- `m4`: procesador de macro sencillo 
 
 - `yes`: imprime un string sin fin
 
@@ -317,11 +317,11 @@ Algunos ejemplos de comandos reunidos:
 
 - `printenv`: imprime las variables del ambiente (útil en depuración y scripts)
 
-- `look`: buscar palabras en English (o líneas en un archivo) comenzando con un string
+- `look`: buscar palabras en inglés (o líneas en un archivo) comenzando con un string
 
 - `cut`, `paste` y `join`: manipulación de datos
 
-- `fmt`: formato de texto de parrafo
+- `fmt`: formato de texto de párrafo
 
 - `pr`: formato de texto en páginas/columnas
 
@@ -329,7 +329,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `column`: formato de texto en columnas o tablas
 
-- `expand` y `unexpand`: convertidor entre tabs y espacios
+- `expand` y `unexpand`: convertidor entre tabuladores y espacios
 
 - `nl`: agrega números de línea
 
@@ -351,7 +351,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `dd`: moviliza data entre archivos y dispositivos
 
-- `file`: identifica el typo de archivo
+- `file`: identifica el tipo de archivo
 
 - `tree`: muestra directorios y subdirectorios como un árbol anidado; parecido a `ls` pero recursivo
 
@@ -359,7 +359,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `tac`: imprime archivos en forma inversa
 
-- `shuf`: selección de líneas de un archivo de forma aleatorea
+- `shuf`: selección de líneas de un archivo de forma aleatoria
 
 - `comm`: compara archivos ordenados línea por línea
 
@@ -369,7 +369,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `strings`: extrae textos de archivos binarios
 
-- `tr`: traducción y manipulación de caracter
+- `tr`: traducción y manipulación de caracteres
 
 - `iconv` o `uconv`: conversión de codificaciones de texto
 
@@ -383,7 +383,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `ldd`: información de librería dinámica
 
-- `nm`: archivo de objeto de simbolos
+- `nm`: archivo de objeto de símbolos
 
 - `ab`: benchmarking de servidores web
 
@@ -413,7 +413,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `last`: historial de login
 
-- `w`: quien esta autenticado?
+- `w`: quien está autenticado?
 
 - `id`: información de identidad de usuario/grupo
 
@@ -431,7 +431,7 @@ Algunos ejemplos de comandos reunidos:
 
 - `lsblk`: lista de bloques de dispositivos: un árbol de vista de sus discos y particiones de disco
 
-- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: información de hardware, incluyendo CPU, BIOS, RAID, grafícos, dispositivos, etc.
+- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: información de hardware, incluyendo CPU, BIOS, RAID, gráficos, dispositivos, etc.
 
 - `fortune`, `ddate`, y `sl`: um, bien, este depende si tiene la consideración de locomotoras de vapor y citas Zippy "práctico"
 
@@ -448,7 +448,7 @@ Estos son puntos relevantes *solo* en MacOS.
 
 - Spotlight: Busca archivos con `mdfind` y listar metadata (como información de foto EXIF) con `mdls`.
 
-- Tenga encuenta que MacOS esta basado en BSD Unix, y cualquier comando (por ejemplo `ps`, `ls`, `tail`, `awk`, `sed`) tiene variaciones discretas variaciones por cada Linux, que esta en gran parte influenciado por el sistema Unix V-style y herramientas GNU. Puedes frecuentemente decirme la diferencia por señalar unas páginas man que tienen el encabezado "BSD General Commands Manual." En algunos casos versiones GNU pueden ser instalados, también (tales como `gawk` y `gsed` para awk y sed del GNU). Si escribe cross-platform scripts Bash, evita tales comandos (por ejemplo, considerando Python o `perl`) o probar con mucho cuidado.
+- Tenga en cuenta que MacOS está basado en BSD Unix, y cualquier comando (por ejemplo `ps`, `ls`, `tail`, `awk`, `sed`) tiene variaciones discretas variaciones por cada Linux, que está en gran parte influenciado por el sistema Unix V-style y herramientas GNU. Puedes frecuentemente decirme la diferencia por señalar unas páginas man que tienen el encabezado "BSD General Commands Manual." En algunos casos versiones GNU pueden ser instalados, también (tales como `gawk` y `gsed` para awk y sed del GNU). Si escribe cross-platform scripts Bash, evita tales comandos (por ejemplo, considerando Python o `perl`) o probar con mucho cuidado.
 
 
 ## Más recursos