01-cli-basico.Rmd

---
title: "La línea de comandos"
author: 
- "Adolfo De Unánue T."
- "Revisado y actualizado por: Andrea Fernández"
date: "`r format(Sys.time(), '%Y-%m-%d')`"
output: 
  html_document:
    toc: yes
    toc_float: yes
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = FALSE)
```

# Checamos la instalación

Estamos ahora trabajando en Ubuntu. Ojalá decidan cambiarse a este sistema operativo.

Lo más complejo de migrar suele ser aprender a instalar cosas pues, aunque algunas cosas cuentan con un ejecutable que se puede instalar desde un package manager, en general las cosas deben instalarse desde línea de comandos. Para ello hay que leer manuales y suele ser engorroso. 

En github, hay algunas instalaciones preparadas por usuarios, tal es el caso de [skalas/massive-adventure-ubuntu](https://github.com/Skalas/massive-adventure-ubuntu).

Hay muchos ejecutables pero lo importante para poder tomar ese repositorio -luego entramos en detalles de github- es que tengan instalado git. Para eso, en todos los Sistemas Operativos (SO) basados en debian (como ubuntu) deben ejecutar en la terminal (ctrl + alt + t):

```
sudo apt-get install -y git curl libcurl4-openssl-dev build-essential
mkdir -p $HOME/src
```

Despues, donde esten digiten:

```
cd
mkdir repos_utiles
cd repos_utiles
git clone https://github.com/Skalas/massive-adventure-ubuntu.git
cd massive-adventure-ubuntu
./i_bash_tools.sh
./i_docker.sh
./i_pyenv.sh
```

Despues (ahorita saturariamos la red) instalen otras cosas como `i_R.sh` o `i_python.sh`.

# Bash - basico

**NOTA**: Esta *lecture* está basada parcialmente en las notas del curso C4P de California Polytechnic State University, San Luis Obispo

# Introducción

El `shell` de Unix (en su caso particular es un `shell` de
`GNU/Linux`), es más viejo que todos nosotros. Y el hecho de que siga
activo, y en uso, se debe a que es una de las invenciones humanas más
exitosas para usar la computadora de manera eficiente.

De una manera muy rápida el `shell` puede hacer lo siguiente:

- Un intérprete interactivo: lee comandos, encuentra los programas
  correspondientes, los ejecuta y despliega la salida.
  - Esto se conoce como **REPL**: *Read, Evaluate, Print, Loop*
- La salida puede ser redireccionada a otro lugar además e la
  pantalla. (Usando `>` y `<`).
- Una cosa muy poderosa (y en la que está basada --como casi todo lo
  actual--) es combinar comandos que son muy básicos (sólo hacen una
  sola cosa) con otros para hacer cosas más complicadas (esto es con
  un *pipe* `|`).
- Mantiene un histórico que permite rejecutar cosas del pasado.
- La información es guardada jerárquicamente en carpetas o directorios.
- Existen comandos para hacer búsquedas dentro de archivos (`grep`) o
  para buscar archivos (`find`) que combinados pueden ser muy
  poderosos.
  - Uno puede hacer *data analysis* solamente con estos comandos, así
    de poderosos son.
- Las ejecuciones pueden ser pausadas, ejecutadas en el *fondo* o en
  máquinas remotas.
- Además es posible definir variables para usarse por otros programas.
- El `shell` cuenta con todo un lenguaje de programación, lo que
  permite ejecutar cosas en **bucles**, **condicionales**, y hasta
  cosas en paralelo.

# La computadora desde cerca

Al final las computadoras sólo hacen cuatro cosas:

- Ejecutan programas
- Almacenan datos
- Se comunican entre sí para hacer las cosas recién mencionadas.
- Interactúan con nosotros.
  - La interacción puede ser gráfica (como están acostumbrados)
    conocida también como **GUI** (*Graphical User Interface*) vía el
    ratón u otro periférico, o desde la línea de comandos, llamada
    como **CLI** (*Command Line Interface*).

# El ambiente desde cerca

El ambiente está formado por 4 capas:

- Herramientas de línea de comandos
  - De estos hay cinco tipos: Ejecutable Binario, *Builtin*, *Script* Interpretado, Función del *Shell* y `alias`.
- Terminal
- *Shell*
- Sistema Operativo

# La línea de comandos

La línea de comandos es lo que estará entre nosotros y la computadora
casi todo el tiempo en este curso. De hecho, una lectura obligada (no
me hagan que la deje de tarea es
[In the beginning...was de command line](http://faculty.georgetown.edu/irvinem/theory/Stephenson-CommandLine-1999.pdf)
de *Neal Stephenson*, el escritor de
[**Criptonomicon**.](https://play.google.com/store/books/details/Neal_Stephenson_Cryptonomicon?id=dwAwSzmTHNEC).


La **CLI** es otro programa más de la computadora y su función es
ejecutar otros comandos. El más popular es `bash`, que es un acrónimo
de *Bourne again shell*. Aunque en esta clase también usaremos `zsh`.


# Archivos y directorios

La computadora guarda la información de una manera ordenada. El
sistema encargado de esto es el `file system`. Básicamente es un árbol
de información (aunque hay varios tipos de `file systems` que pueden
utilizar modificaciones a esta estructura de datos, lo que voy a decir
aplica desde su punto de vista como usuarios) que guarda los datos en
una abstracción que llamamos *archivos* y ordena los archivos en
*carpetas* o *directorios*, los cuales a su vez pueden contener otros
*directorios*.

Muchos de los comandos del **CLI** o `shell` tienen que ver con la
manipulación del `file system`.

> Ejercicio:

- Inicia una sesión en `bash`.
- Deberías de ver algo como esto:

```
~
```

> Ejercicio: **Quién eres**.

- Teclea `whoami` y luego presiona *enter*. Este comando te dice que
usuario eres. Observa que el usuario actual es `bancomer`. Éste es un usuario normal. 
- Teclea `sudo su` y vuelve a teclear `whoami`. Este otro usuario, llamado `root` es un **superusuario** (su \= superuser), él tiene poderes para modificar todo, obvio, esto es peligroso, por lo que será mejor cambiar de usuario, en particular al usuario `bancomer`.
- Teclea `su bancomer`. ¿Qué pasó?
- Comprueba que eres el usuario `bancomer` ¿Cómo le podrías hacer?

> Ejercicio:  **Dónde estas**.

- Para saber donde estamos en el `file system` usamos `pwd` (de
*printing working directory*).
- Al teclear `pwd` debe salirte el **home**, en este caso, `/home/bancomer`
- El **home** es un directorio importante. Cada usuario en una computadora, en la que sea, tiene un home, en donde goza de todos los permisos de lectura/escritura/ejecución.
- En este directorio se guardan todas las configuraciones personalizadas para tu máquina. Normalmente, como archivos ocultos (por ejemplo, `.zshrc`)
- El **home** tiene otras particularidades que [iremos descubriendo](https://help.ubuntu.com/community/HomeFolder)

> Ejercicio: **Qué tienes**.

- Para ver el listado de un directorio usamos `ls`
- Ahora estás observando la estructura de directorios del **home** `~/`.
- Los comandos (como `ls`) pueden tener modificadores o *banderas*,
las cuales modifican (vaya sorpresa) el comportamiento por omisión
del comando. Intenta con `ls -l`,  `ls -a`, `ls -la`,  `ls -lh`, `ls
-lha`. Discute con tu compañero junto a tí las diferencias entre las banderas.
- Para obtener ayuda puedes utilizar `man` y el nombre del
comando. ¿Cómo puedes aprender qué hace `ls`?

> Ejercicio: **Cómo te mueves**.

- El comando `cd` permite cambiar de directorios (¿Adivinas de donde viene el nombre del comando?) La sintáxis es `cd nombre_directorio`. 
- En donde quiera que estés (`pwd`) te puedes mover de ahí a cualquier otro directorio. Esto es importante pues introduce el concepto de *rutas relativas*. Relativas porque van *a partir* de cierto directorio. Hablaremos mucho de eso más adelante. 
- Para ir *un nivel arriba* del directorio en el que estás, se debe teclear `cd ..`
- A partir del home, teclea `cd ../..`. Estamos en un directorio que se conoce como el raíz o *root* del sistema, el cual es
simbolizada como `/`.
- Teclea `ls -la`. ¿Qué ves?
- ¿Puedes regresar a tu `$HOME`?
- Teclea `cd /home/bancomer`. 
- ¿Qué hay de diferente si ahí ejecutas `ls -la`?
  - Las dos líneas de hasta arriba son `.` y `..` las cuales
  significan *este directorio* (`.`) y el directorio padre (`..`)
  respectivamente. Los puedes usar para navegar (i.e. moverte con
  `cd`)
- ¿Puedes regresar a raíz?
- En raíz ¿Qué pasa si ejecutas `cd $HOME`?
- Otras maneras de llegar a tu `$HOME` son `cd ~` y `cd` solito. Si al comando *change directory* no le das nada, se mueve a tu home por default. 

> Ejercicio:  **Qué está definido hasta ahora**.

- Las variables de sistema (es decir globales en tu sesión) se pueden
obtener con el comando `env`. En particular presta atención a
`HOME`, `USER` y `PWD`.
- Otro comando muy útil (aunque no lo parecerá ahorita) es `echo`.
- Teclea `echo Hola mundo!`.  
- Para evaluar la variable podemos usar el signo de moneda `$`,
- Imprime las variables mencionadas arriba con `echo`, e.g. `echo $USER`.

> Ejercicio: **Crear nuevos directorios**.

- Verifica que estés en tu directorio (¿Qué comando usarias?) Si no
estás ahí, ve a él.
- Para crear un directorio existe el comando `mkdir` que recibe como
parámetro un nombre de archivo.
- Crea la carpeta `test`. Entra a ella. ¿Qué hay dentro de ella?

> Ejercicio: **Creamos nuevos archivos**.

- Vamos a crear un archivo de texto, para esto usaremos **GNUEmacs**. **GNU Emacs** es un editor de textos muy poderoso. Lo
aprenderemos en la clase (y quizá en algún seminario). Por el momento
teclea `emacs hola.txt` (puedes usar `nano hola.txt` si no tienes emacs) y presiona enter (la primera vez que lo corras
puede tardar mucho, está instalando toda la configuración para la
clase).
- Aparecerá una barra de menú abajo. Esto indica que ya estás en **GNU
Emacs**. Teclea "¡Hola Mundo!" y luego presiona la siguiente
combinación de teclas: `Ctrl+x` seguido de `Ctrl+s` (guardar cambios). Ahora presiona
`Ctrl-x` y luego `Ctrl-c` (salir de emacs). Esto los devolverá a la
**CL**.
- Verifica que esté el archivo.

> Ejercicio: **Borramos archivos**.

- Para borrar usamos el comando `rm` (de *remove*), ¿cómo crees que se borraría un directorio?
-  Borra el archivo `hola.txt`.
- ¿Ahora puedes borrar el directorio `test`? ¿Qué falla? ¿De dónde
puedes obtener ayuda?
- Crea otra carpeta llamada `tmp`, crea un archivo `copiame.txt` con
emacs, escribe en él: "Por favor cópiame".
- Averigua que hacen los comandos `cp` y `mv`.
- Copia el archivo a uno nuevo que se llame `copiado.txt`.
- Borra `copiame.txt`.
- Modifica `copiado.txt`, en la última línea pon "¡Listo!".
- Renombra `copiado.txt`  a `copiame.txt`.
- Por último borra toda la carpeta `tmp`.

# Navegar

Moverse rápidamente en la **CLI** es de vital importancia. Teclea en tu **CLI**

```
Anita lava la tina
```

Y ahora intenta lo siguiente:

- `Ctrl + a` Inicio de la línea
- `Ctrl + e` Fin de la línea
- `Ctrl + r` Buscar hacia atrás
  - Elimina el *flechita arriba*
- `Ctrl + b` / `Alt + b`
- `Ctrl + f` / `Alt + f`
- `Ctrl + k` - Elimina el resto de la línea (en realidad corta y pone en el búfer circular)
- `Ctrl + y` - Pega la último del búfer.
- `Alt + y`  - Recorre el búfer circular.
- `Ctrl + d` - Cierra la terminal
- `Ctrl + z` - Manda a *background*
- `Ctrl + c` - Intenta cancelar

# Pipes y flujos

- `>`,`>>`, Redirecciona la salida de los comandos a un sumidero.

```
ls >> prueba.dat
```

- `|` (pipe) “Entuba” la salida de un comando al siguiente 

```
cat prueba.dat | grep -e "Do"
```

- En realidad pude haber "entubado" los dos comandos anteriores:

```
ls >> prueba.dat | grep -e "Do"
```

- `<` Redirecciona desde el archivo

```
sort < prueba.dat # A la línea de comandos acomoda con sort,
sort < prueba.dat > prueba_sort.dat # Guardar el sort a un archivo.
cat prueba.dat # lo vemos
```

**Nota** como puedes poner lo que sea despues del `#`. En bash, se comenta con esto.

- `&&` es un AND, sólo ejecuta el comando que sigue a `&&` si el
primero es exitoso.

```
ls && echo "Hola"
lss && echo "Hola"
```


# Otros comandos

- `wc` significa *word count*
  - Cuenta palabras,renglones, bytes, etc.

- En nuestro caso nos interesa la bandera `-l` la cual sirve para contar líneas.


```
wc -l /etc/passwd
```

- `head` y `tail` sirven para explorar visualmente las primeras diez
(default) o las últimas diez (default) renglones del archivo,
respectivamente.


```
head /etc/passwd
tail -3 /etc/passwd
```

- `cat` concatena archivos y/o imprime al `stdout`

```
echo 'Hola mundo' >> test
echo 'Adios mundo cruel' >> test
cat test
```

- `cp origen destino` permite copiar un archivo o directorio a otro lugar

```
cp test test2
cat test test2 > test3
wc -l test*
```

Existen otros comando poderosos como `split`, `uniq`, `grep`, etc.


----

Con estos ejercicios deberías de ser capaz de manejar los básicos del
`file system` y de la línea de comandos


# Antes de partir... ¿Por qué usamos `zsh` en lugar de `bash`?

`zsh` es un `bash` recargado, para saber que puede hacer revisa
[esto](http://www.bash2zsh.com/zsh_refcard/refcard.pdf) y
[esto](https://github.com/robbyrussell/oh-my-zsh/wiki/Cheatsheet).

# Ejercicios sugeridos

- [Codecademy - Learn the Command Line](https://www.codecademy.com/learn/learn-the-command-line)