¿Para qué compilar desde fuente?

Sigo sin entender para qué cojones debo de compilar.

Así pensaba yo también. No tiene sentido usar algo si no entiendo primero su utilidad. Te comparto un ejemplo/experiencia que tuve. 

Me moví a Arch porque busco algo más ligero que Freya y a la vez, algo que me ayude a aprender sobre la instalación y mantenimiento del sistema operativo: algo que me permita "tener control" de los detalles, para aprender de estos. Como sabemos, Arch requiere ser instalado "desde el suelo": el sistema base no tiene GUI, es sólo el prompt y una CLI. Vos agregás componentes según tu voluntad y preferencias.

Estoy usando Awesome WM en lugar de un Destkop Environment completo. También uso urxvt como Terminal, en lugar de una terminal pesada. Esto hace mi escritorio ligero. Ahora bien, extraño la transparencia en Terminal, como la de Pantheon-Terminal en Freya, porque permite trabajar en Terminal sobre tu navegador por ejemplo, y leer cosas mientras trabajás en Terminal. Esto me lleva a un predicamento: 

• Podría instalar Pantheon-Terminal en Arch, pero no quiero algo tan pesado ni con barra de menú porque es un desperdicio de pixeles... más aun en una laptop. Quiero ahorrar pixeles y dedicarlos a más contenido, no a botones.
• En todo caso, la selección de Terminal no es el problema; Awesome WM no soporta transparencias de manera nativa, sino que require un "composite manager", gestor de composición de ventanas para lograrlo. Esto significa que puedo usar virtualmente cualquier Terminal y tener transparencia, siempre y cuando tenga un Composite Manager.

Después de documentarme, aprendí que el Composite Manager llamado Unagi, es ligero y de hecho,  fue desarrollado para Awesome WM. Unagi es un paquete adicional en Arch (y diría que en muchas otras distros). No toda la gente lo usa ni lo necesita, así que no tiene sentido para los desarrolladores de Arch, incluirlo como paquete oficial en el sistema base; hacerlo sería abusar del almacenaje de quienes no lo usarán: esta sería una definición justa del término BLOATWARE. Por eso Unagi está en el AUR, el Repositorio de Usuarios de Arch; acá hay software de calidad, en tarballs, listo para ser descargado, compilado e instalado manualmente por quien desee usarlo. 

Así que, para ejemplificar los pasos que te compartí antes, hice lo siguiente:

$ wget https://aur.archlinux.org/cgit/aur.git/snapshot/unagi.tar.gz

$ tar xvf unagi.tar.gz

$ cd unagi 

$ cat PKGBUILD 

$ makepkg -s 

$ sudo pacman -U unagi.tar.xz

Explicación: descargué el tarball (paquete comprimido), lo extraje, creó un directorio con contenido; me moví a ese directorio, leí el script de instalación o PKGBUILD (es recomendado leer el script de instalación -si entendés de bash-scripting :v para confirmar que el script está limpio y no tiene nada malicioso.); compilé el paquete asegurándome de forzar dependencias a ser instaladas (el script incluye referencias a esas dependencias), e instalé el paquete... aunque pude ahorrarme la última línea y usar $ makepkg -sri  en su lugar.

Y listo. Ahora que tengo Unagi instalado, puedo trabajar en las configuraciones apropiadas dentro de Awesome para hacer que mi terminal sea transparente. Y esa, es otra historia. Hasta pronto :)

Overview: Instalar paquetes desde el código fuente.

A veces no encontrarás cierto software en los repos oficiales de tu Distro. Esto es por diversas razones: a lo mejor es software privativo y ponerlo en los repos oficiales contradice la filosofía de la Distro, o no es soportado directamente porque no es totalmente estable o compatible con la Distro o su DE oficial; tal vez está en versión Beta o Alfa incluso, etc. Sin embargo, siempre podés instalar ese software, si vas a un repo no-oficial de tu Distro (como el AUR en Arch) o si vas a un repo externo. Lo que tenés que hacer es algo llamado "compilar el código fuente" (compile/build from source).

Vamos a detallar las instrucciones para compilar en la CLI desde Arch. En esencia, el procedimiento total es igual en toda Distro, pero algunos comandos cambian. 

Pre-requisitos.

Antes de todo, necesitás: 

• Un usuario regular. Por motivos de seguridad no podés instalar paquetes del AUR o repositorios externos, desde Root. 
• Truco personal: tengo un directorio dentro de /home/usuario exclusivo para descargar paquetes fuente y compilarlos. $ mkdir ~/AUR_downloads
• Que Arch tenga instalado el base-devel (devel= "development"; o sea, un conjunto de paquetes para desarrollo): $ pacman -S --needed base-devel
• Específicamente, los paquetes que se requieren son: 
• gcc (Compilador GNU para C, C++, Java, etc.)
• wget (para descargar los paquetes comprimidos, alias "tarballs")
• makepkg (para compilar localmente)
• fakeroot (como dije en el punto principal anterior, instalar como root no es recomendado ni permitido; fakeroot "emula" un ambiente root para instalar paquetes desde código fuente).
   

Procedimiento.

Una vex tenés todo esto, podés instalar paquetes no-oficiales. En esencia, el proceso es simple: 

• Descargar el paquete, o tarball (esto es un archivo .gz; usás wget).
• $ wget foo.gz
• Descomprimir/extraer el paquete ( se usa $ tar xvf ); un directorio nuevo es creado (Por eso tengo un fólder sólo para paquetes, para mantener todas los tarballs y los directorios extraídos organizados) con algunos archivos; PKGBUILD, README y otros. compilados.
• $ tar xvf foo.gz
• $ cd foo
• Compilar e instalar el paquete (en Arch se usa $makepkg; en otras distros esto puede variar); esto producirá un archivo con el nombre del paquete, en formato .xz). Se puede con una de estas formas:
• $ makepkg -sri   (compila, resuelve dependencias e instala).
• O de esta forma: 
• $ makepkg -s
• $ sudo pacman -U foo.xz
• Regocijarte y fappear a lo grande. 

Menos es más: Linux para equipo legacy y de gama baja

frugalidad.

(Del lat. frugalĭtas, -ātis).

1. f. Templanza, parquedad en la comida y la bebida.

A veces no necesitás más RAM, un CPU* más costoso, una PC nueva o una versión más reciente de Windows. A veces sólo necesitás reconsiderar tus paradigmas y hábitos. A veces no necesitás más mierda, al contrario; a veces lo que tenés es suficiente, y en algunos casos incluso necesitás dejar ir cuanta mierda sea posible de tu vida en lugar de envidiar a otros y ansiar más. 

Lo que me gusta de Linux en comparación a sistemas privativos, es su flexibilidad. Podés usarlo en una máquina de mil dólares como podés instalarlo en un equipo viejo o de gama baja y aun así tener una PC funcional que te dure largo rato. 

Vamos a considerar equipo legacy y de GAMA baja a: 

• 2GB de RAM o menos, (en legacy, DDR2 o anterior).
• Procesador de dos núcleos actual, o uno socket LGA775 o Socket AM2 (estas plataformas fueron lanzadas entre el 2005-2006)
• Video integrado o incluso, una gráfica discreta entry-level
• Interfaz SATA II - IDE 
• Laptops doble nucleo de bajo consumo con procesadores AMD serie A/Thurion/Zacate/Athlon, o Intel Celeron/Pentium/Atom de generaciones viejas. Cualquier cosa que tenga cuatro threads, podemos o un Turbo Booster, podemos considerarlo algo de gama mayor.

 

 

Esencialmente, lo que buscás es EVITAR EL BLOATWARE.

 

Para principiantes, instalar una distro con cualquiera de estos entornos ligeros/window managers:

• LXDE
• XFCE
• LXQT 
• Mate
• Openbox

Listo. Para un novato que quiere algo simple, listo y fácil de usar; eso sería lo que busca. Podemos mencionar algunos ejemplos (pero sigo recomendando, buscar en línea por más alternativas en distrowatch.com):

Xubuntu, Lubuntu, BunsenLabs, CrunchBang Plus Plus (derivados del extinto y mítico Crunchbang, desarrollado por Corenominal), Fedora XFCE spin o LXDE spin, Linux Mint, Puppy Linux, Porteus, Point Linux.

Para novatos atrevidos e intermedios  instalar un sistema base; esto provee mejor control sobre qué instalar/usar, y aprovechamiento de recursos... aunque requiere mayor conocimiento y tiempo.

• O sea, la pura CLI, y comenzar a construir su propio escritorio desde ahí.
• Debian.
• Arch
• Incluso si no instalás Arch, su Wiki es asombrosa.
• Slitaz
• Slackware
• Gentoo
• También tienen documentación excelente.
• Ubuntu mínimo
• Francamente, he encontrado info útil en su foro angloparlante.
• Cualquier cosa que diga "CLI" o "No GUI" cuando completás su instalación.
• Instalar un gestor de ventanas en lugar de un entorno completo, como por ejemplo:
• Flotantes:
• Blacbox o sus derivados a continuación:
• Openbox.
• Fluxbox.
• Tiling o de "fichas/bloques" (podrán parecer feos o "simples" a quienes vienen acostumbrados al maquillaje y demás superficialidades: 
• Awesome Window Manager (también es flotante)
• DWM
• Xmonad
• i3 
• JWM (usado en Puppy)
• Usar aplicaciones minimalistas y de preferencia, basadas en Terminal en lugar de una GUI (particular , por ejemplo:
• midnight commander como visor de archivos/directorios ($cm)
• $top o $htop en lugar de Gnome System Monitor. 
• nano/vim/emacs en lugar de gedit, scratch, atom, etc. Aquí hay argumentos sólidos por parte de programadores para seguir usando un editor de texto pesado (se integran con sus IDEs, tienen autocompletar, etc.); para un novato, sería sano seguir mi recomendación.
• Hay incluso, navegadores en CLI: Lynx, por ejemplo. 
• 
  
• Usar la jodida CLI, CLI, CLI. 

Esto te va a permitir ahorrar espacio en disco y evitar desperdiciar segundos al arranque con cosas que no necesitás/no usás. Naturalmente, para lograr esto, necesitás más tiempo, conocimiento, etc.

*Cuando digo CPU, no me refiero al "cajón", "case" o "chassis", me refiero al microchip, microprocesador, el Intel, AMD, VIA, ARM, de un computador.

Manipulando I/O con pipelines.

Advertencia:

• Recomiendo leer las entradas de $man  $cat, $watch, $history y $less antes de seguir leyendo esto.

• He recomendado previamente wikear e investigar acerca del concepto I/O. Es importante que veamos todas las interacciones con nuestras PCs (y yo me atrevo a incluir, la vida en general) de esa forma: 

Input | Output

Entrada | Salida

O sea: 

Causa | Efecto

Instrucciones | Resultados.

Mientras entendamos esto, todo bien; caso contrario, te toca leer manuales externos porque a este punto, asumimos que estamos claros con este concepto y evitaremos elaborar.

Intro:

He instalado VirtualBox en un servidor. Me conecto al servidor desde mis otros equipos desde la CLI (eso es un cuento para luego... ahorita no joven). Hice una pausa en este proyecto por un par de semanas porque obtuve una netbook de segunda mano y he pasado jugando con Arch en ella. Para configurar una virtualbox en Terminal, hay que hacer varias cosas y apenas las recordaba hoy, enero/16; a grandes rasgos: crear una nueva virtual machine, asignarle x cores del cpu, x cantidad de RAM y VRAM, crear un HDD virtual, un ODD virtual, agregar controlador, etc.

Viendo a futuro, y contando con que planeo usar otra unidad de arranque para el servidor, o pueda cagarme en algo (cosa que hago a menudo :v ), probablemente necesite reinstalar virtualbox, o al menos borrar una VM, clonar, crear, restaurar otra. Por ello, quiero guardar un resumen de los comandos usados (como lo hice al aprender a instalar Arch recientemente); a modo de referencia.

**** Resumen ****

Necesito extraer los comandos que he usado para configurar la VM dentro del servidor. El comando (el principal) para gestionar Virtual Machines dentro de VirtualBox en la CLI es:

$vboxmanage
(o sea, "virtualbox manage": gestionar caja virtual). Recuerdo que lo he usado una, y otra, y otra**10 vez). Tuve una idea: buscar todas las instancias de ese comando, copiarlas y pegarlas en un documento de texto que luego puedo guardar en mi netbook u otro equipo. Para ello:

$ history | grep -i vboxmanage > vbox_resumen-de-comandos.txt

Y listo. Si has revisado las entradas antes mencionadas, sobran las explicaciones. Una vez creado el documento, lo abro:

$ less  vbox_resumen-de-comandos.txt

Y veo  todas las instancias que he usado del mismo comando (algunos de ellos, repetidos o con "typos"). Luego de eso, es posible editar  y depurar los errores (con gedit, leafpad, nano, etc.); incluso, puedo agregar notas aclaratorias. Creo tener una entrada antigua sobre editores de texto en este blog; te invito a buscarla. Eso es todo; gracias por leer :D

History: registro de comandos.

A veces olvido los comandos que he usado. Cuando esto pasa, escribo:

$ history

Con esto veo los comandos ejecutados por el usuario actual. Si quiero saber el usuario conectado, hago:

$ whoami
(como en who am I?)

A veces opero como root; entonces para ver los comandos ejecutados como root, hago esto:

$ su root
(ingreso password)
# history
(recordemos que el #, signo numeral, hash o hashtag, representa a root)


Y ellos aparecen. Si nuestro historial de comandos es extenso, apenas veremos los comandos recientes en panatalla; dependiendo de la Terminal desde la cual ejecutamos esto, a veces el scrolling con el mouse o la barra de scrolling vertical no funcionan; entonces nos apoyamos de otro comando: less, capaz de recibir el input de history  por medio de una pipeline (se dice "paip-lain"; hemos mencionado esto antes a grandes rasgos y te invitamos volver a leer esa entrada para aprender/recordar) y procesarlo de forma navegable. Recordemos el asunto del I/O:

input | output

entrada | salida

El asunto suena complejo, pero es tan simple como escribir esto:


$ history | less
y listo. Sin complicarnos. Vas a poder navegar a lo largo de todos los comandos (enumerados) que has escrito.

El mejor ejemplo que podemos usar, es aplicar la pipeline a tu PC. Adelante y hasta luego :)


EDITADO, enero/17, 00:44 horas, San Salvador: el colega Carlos Egüez mencionaba hace una hora en nuestro grupo, algo que he olvidado incluir:

••• Control + R en el prompt regular de Terminal: busca interactivamente un comando y muestra resultados a lo "auto completar".

••• Seguido de
$ history | less

el comando "history" enumera los resultados; una vez has identificado el comando que vas a reutilizar, es posible hacer esto:

$ !n 
donde n es el numeral que identifica al comando deseado. Por ejemplo, un fragmento de mis comandos:

486  screenfetch
 487  scrot
 488  clear

$ !486
es lo mismo que gatillar:

$ screenfetch.

Gracias Carlos por el feedback :D es exactamente esto para lo cual debe de existir la comunidad.

Less: leer output con calma.

Te aconsejamos wikear los conceptos "input" y "output", o "entrada" y "salida" respectivamente. Para que la PC haga algo, hay que ordenarle por medio de comandos, clicks, enter, etc. cada vez que lo hacemos, le damos un input; esta analiza/procesa/opera/transforma/computa/se coge al input y usualmente luego,  te muestra/vomita/escupe/caga la respuesta en la cara: esto es el output.

Imaginemos que queremos leer un documento, tarea, reporte, chat sexual travieso o cualquier cosa que tengamos guardada en la PC. Como lo vimos antes, podemos usar

$ cat nombre_del_asunto

$ cat toma el input, busca el archivo; si lo encuentra, te lo muestra; caso contrario te saca el dedo y dice que no lo encuentra. En ambos casos hay input-output. Digamos que todo va bien; el resultado se mira a grandes rasgos: 

output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output y listo.

Esto va muy bien si el documento es breve y tenemos un display con suficiente espacio vertical, y si hemos maximizado la ventana de Terminal. Cuando no es este el caso, veremos solamente el final del documento: 

$ cat derechos_universales_de_los_ortos_peludos

maldita sea, una idea incompleta... output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output output este es apenas el culo de todo el documento... la cagaste, jaja.

Cuando esto sucede, mandamos a la mierda a $cat y usamos 

$ less 

quien permite navegar con las flechas (prefiero esto:  jode menos las manos y evita quemar tiempo innecesario al despegar una mano del teclado para usar el mouse) del teclado.

De nuevo:

$ less

Toma tu input (el nombre de un archivo de texto, script, incluso el output de otro comando... pero eso no lo veremos ahora) y te da el output de forma navegable; la Terminal cambia al "modo visual"; este "modo visual" es tomado de VI (se dice "vi ai", "uve i" un editor de texto legendario, usado por algunos programadores profesionales aun). Para salir de este modo, al igual que para salir de VI, presionamos "q" como en quit; y listo. Hay mucho para hablar al respecto de less; esto nos basta por el momento; te recomendamos #RTFM (read the fucking manual) para mayor info:

$ man less

$ less --help

((por cierto, ambos comandos mostrados arriba usan el "modo visual" de VI: "q" para salir)

Y listo.

Por cuestiones de eficiencia y practicidad, en lugar de poner un ejemplo, te invito a realizar este ejercicio: localizar las licencias GNU-GPL en el filesystem de tu distro para comparar el uso de cat y less; vas a notar la diferencia,

$ less es un comando muy flexible. La flexibidad es poder. Hasta luego :)

Comando watch: ejecución de programas periódicamente

NOTA: Como lo mencionaba antes, los artículos que compartiré de ahora en adelante pueden o no ser adecuados para novatos; porque requieren un poco más de esfuerzo y conocimiento para previo para entenderlos. Este artículo habla de  dos cosas: primero, el uso de un comando nuevo y muy útil, pero cuyo potencial no se aprovecha si no hablamos de lo segundo: las pipelines o tuberías. No vamos a profundizar en el segundo aspecto porque, aunque no es extenso, requiere especial atención y dedicación; le veremos de grosso modo para entender la flexibilidad de los sistemas operativos Unix. Si estás interesado en las pipelines, te sugerimos investigar en línea mientras publicamos algo dedicado a ellas. 

Según 

$ whatis watch

watch (1)            - execute a program periodically, showing output fullscreen

Traduciendo: 

watch (1: comando de usuario) - ejecutá un programa periódicamente, mostrando el resultado en pantalla completa (o sea, abarca toda la Terminal).

Watch es un programa que ejecuta programas. ¿Por qué "watch" ("observar", "mirar")? ni idea; no lo he buscado, pero sospecharía que tiene que ver con su propósito: mostrar el resultado (el output) en la Terminal. Esto nos puede ayudar cuando queremos observar cambios en un documento o un proceso.

Por ejemplo,

Me estoy descargando un archivo de internet. Digamos que cerré la interfaz de la aplicación pero ella sigue corriendo en el background y no quiero volver a abrirla ―por pereza o porque no quiero que su GUI me gaste RAM que puedo dedicar a otra cosa― pero quiero saber cómo va la descarga. Entonces, recuerdo que antes hablábamos del comando ls, útil para LISTAR directorios y archivos en el filesystem. 

ls -s muestra el tamaño de los archivos (en Bytes, pero esto puede ser modificado según se necesite: $ ls --block-size=1M)

Entonces, si watch me permite ejecutar un programa cada cierto tiempo, puedo hacer que watch monitoree el tamaño del archivo, reportado por ls -s, conforme crece):

$ watch -n4 ls -s downloads/archivo_siendo_descargado_por_otro_programa

Te recuerdo que podés hacer esto para un archivo localizado en cualquier directorio si sabés la ruta absoluta o relativa a usar. Y esto te reportará un output así:

Instalamos FreeBSD hace un par de años y pensamos hacerlo de nuevo; esta vez con un poquito más de conocimiento para apreciarle y usarle mejor :)

Otro ejemplo:

(un poco más complejo) El otro día quería ver -por curiosidad- los cambios en tiempo real de la velocidad de mi CPU (cuando digo CPU, me refiero al microchip, al procesador, no al cajón de desktop; este es un término mal usado y debemos de dejar de hacerlo). Un colega en un grupo de Linux en FB decía que Ubuntu mantenía a sus procesador al máximo y por eso calentaba su laptop... pero recuerdo que una vez ya había medido la velocidad de mi CPU en tiempo real con watch dentro de Freya cuando tenía mi Phenom 960T; revisé los documentos de nuevo y para salir de la duda, lo hice en mi laptop nueva. 

La info del procesador se puede obtener de muchas formas según encontré en sitios diversos; pero me voy a enfocar en una manera simple. Primero, te voy a recordar el uso del comando cat.

$ cat /proc/cpuinfo  

muestra información relacionada a tu procesador: 

Según el número de núcleos detectados por tu sistema, esta muestra aparecerá una o más veces con diferente # en el primer campo (processor); en el caso de un Intel móvil, aparece cuatro veces, enumerados del 0 al 3 (este i5 es dual core, pero Intel hace uso de su Hyper Threading, duplicando el número de hilos como si fueran el doble de núcleos).

Y esto es útil, pero hay dos cosas:

• Sólo me muestra la velocidad base (donde está el modelo del cpu) y la velocidad en MHz al momento de ejecutar este comando (2670.281 MHz, o sea, 2.67GHz)

• Me llena la Terminal de información totalmente inútil/que no me importa de momento. Sólo quiero saber los cambios de velocidad en tiempo real o intervalos, no todas las tech specs del cpu.

Aquí es donde watch es útil:

Aplicando Pipelines:

Para mostrarte lo que quiero decir, usaremos adicionalmente el comando (que no vamos a ver con detalle, porque su uso es extenso y flexible) grep, que sirve para buscar patrones específicos de texto en un documento/archivo. 

vamos primero a usar una pipeline para unir a ambos comandos: 

cat | grep 

Esto se leería algo así: 

mostrar info (para el caso, del procesador); y usar una tubería (el " | " es una "pipe" o tubería) para que el resultado de cat, sea procesado por grep, quien se encargará de filtrar la info innecesaria y sólo de mostrar la sección específica que queremos. Las pipelines toman el resultado (output) de un comando y lo usan como info de entrada (input) de otro comando para que este haga una tarea con ella y la procese de forma que dé, otro resultado (otro output).

Vamos entonces con cualquiera de estos: 

$ cat /proc/cpuinfo | grep MHz

$ cat /proc/cpuinfo | grep -i mhz

Ambos van a lo mismo,  la opción " -i " dice a grep que sea indiferente a la capitalzación (en buen salvadoreño: que le valga verga si  hay mayúsculas o no, que igual muestre resultados si los encuentra). Entonces esto nos arroja lo siguiente:

Hasta ahí todo bien. PEEEEEEROOOOOooooOOOOooo... muestrala velocidad grabada al momento de ejecución; no en tiempo real. Aquí hacemos uso de watch: 

$ watch -n2 " cat /proc/cpuinfo | grep -i mhz "

Y este es el resultado: 

"Every 2.0s:" ... con -n2 establecí que watch ejecute cat | grep cada dos segundos. Y los cambios son reportados puntuales: 

-

Y listo.

En resumen: 

• watch nos sirve para ejecutar otros comandos (o sea, otros programas) a intervalos definidos por el usuario/administrador. Así podemos monitorear en tiempo real, procesos y tareas que estamos ejecutando.

• las pipelines ( cuando veás este símbolo en un comando o combinación de ellos " | ", seguramente estás frente a una pipeline) nos sirven para ejecturar comandos consecutivamente, y que el resultado de uno, sea manipulado y procesado por otro.

Ambos ejemplos son relativamente rústicos para las herramientas con las que contamos actualmente; el propósito de estos artículos es 1) familiarizarte con tu Terminal y la CLI, 2) prescindir de bloatware (software innecesario) que desperdicie espacio en tu disco, y de GUIs que utilizan recursos extra para llegar a lo mismo, 3) mostrarte la flexibilidad y potencial de las herramientas de Terminal, valoradas especialmente por SysAdmins veteranos y expertos del FOSS. 

Espero que te haya gustado y sido útil esta nota. Compartila, comentá y avisanos si te gustaría que hablemos de otros temas en particular. Saludos :) 

cat: leer y crear archivos de texto de forma simple

$ whatis cat 

cat (1)              - concatenate files and print on the standard output

Cat, comando de usuario - concatená archivos e imprimilos en salida estándar (en texto, pues).

$ cat /etc/fstab 

muestra las unidades que son montadas automáticamente al arranque del sistema operativo.

$ cat archivo.txt

muestra el contenido del archivo de texto que has indicado. Ahora, recordá que en sistemas UNIX, un documento puede o no tener extensión. Un .png pudiera no terminar en ello, así como un .txt pudiera incluso terminar en .gif. Es el sistema quién escanea el archivo y determina su tipo de extensión. Puse el .txt para ejemplificar; y lo puse usando una ruta relativa: el directorio presente.  O sea, no importa dónde estés en el filesystem, vos podrás visualizar un archivo usando cat, siempre que incluyás la ruta correcta, relativa o absoluta, dependiendo del caso:

$ cat ../home/chepito/documentos/folder1/archivo20

y si ya estás en el folder1, sólo tendrías que hacer:

$ cat archivo20

Cat también puede servir para crear un archivo de texto nuevo, usando redirección de salida de corriente (output stream redirection). No vamos a hablar mucho de esto, sólo te digo que podés usar cat para crear un archivo nuevo de texto, así:

$ cat > archivo_de_texto_nuevo

y cat entrará en "modo interactivo"; en lugar del PS1 (el nombre de tu cursor en Terminal), vas a ver el " > " :

$ cat > archivo_de_texto

>

Y aquí podrás escribir texto, apretando enter para crear una nueva línea:

$ cat > archivo_de_texto

> primera línea para probar cat en modo interactivo

> segunda línea de prueba

> tercera línea, blah blah blah... 

> [ para finalizar, das enter, y luego "Ctrl D" ]

Y cuando hayás terminado, das enter una vez más, y en la línea en blanco apretás Ctrl + D. Esto sale del modo interactivo y guarda cambios. Ahora, mirá los cambios que lograste: 

$ cat  archivo_de_texto

 primera línea para probar cat en modo interactivo

 segunda línea de prueba

 tercera línea, blah blah blah... 

$

Digamos que querés agregar otra línea; entonces vas a usar

$ cat >> archivo_de_texto

> esta línea será agregada al final del documento.

> [ Ctrl D ] 

Uso Ctrl + D para salir y ahora:

$ cat  archivo_de_texto

 primera línea para probar cat en modo interactivo

 segunda línea de prueba

 tercera línea, blah blah blah... 

 esta línea será agregada al final del documento.

$

Recordá: 

$ cat > archivo

te permite crear y agregar líneas de texto a un archivo, sin tener que accesar a un editor. 

$ cat >> arhchivo 

añadirá nuevas líneas a un archivo ya existente, así haya sido creado por cat o por otro editor (gedit, leafpad, vim, nano...). Si por error hacés " > " en lugar de " >> " a un archivo, vas a sobrescribir en lugar de agregar... o sea, vas a mandar a la mierda lo que había antes. Si necesitás editar una línea en particular, mejor usá un editor de GUI o de CLI (gedit, leafpad, nano, scratch editor, vim, emacs, etc.) para navegar hacia la línea deseada.

Resumen: 

¿Para qué me sirve cat? para mostrar el contenido de un archivo de texto en terminal, sin tener que usar herramientas externas, gráficas ni tener que salir de terminal. Esto significa: ahorro de recursos de procesamiento, y tu tiempo. Es usado a menudo para leer rápidamente archivos de configuraciones del filesystem, cuando son cortos. ¿Funciona con largos? Sí, pero no es tan cómodo a menos que tu Terminal tenga soporte de navegación vertical (para scrollear hacia arriba); o a menos que lo usés con una pipe y less; pero eso es otro asunto que no tocaré hoy y no tiene sentido. 

¿Tengo que usarlo? No. Pero existe y podrías beneficiarte de él; sin embargo, a veces podrás preferir un editor completo (así sea de CLI o GUI) como cuando estás leyendo scripts de programación, porque los editores dedicados tienen "resaltador de sintaxis", colorizan palabras claves, strings, booleanos, etc. 

Extender tu partición / (root) sin herramientas gráficas; parte III.

Una vez me conecté, hice lo siguiente:

# df -h

Filesystem      Size  Used Avail Use% Mounted on

dev             3.7G     0  3.7G   0% /dev

run             3.7G  508K  3.7G   1% /run

/dev/sda1        15G  3.4G   11G  25% /

tmpfs           3.7G     0  3.7G   0% /dev/shm

tmpfs           3.7G     0  3.7G   0% /sys/fs/cgroup

tmpfs           3.7G     0  3.7G   0% /tmp

tmpfs           742M     0  742M   0% /run/user/0

Mi directorio root sigue mostrándose como de 11GB. Eso es porque df -h muestra el directorio donde está montada la partición, no la partición como tal. Por eso, volvemos a usar fdisk -l para mostrar las particiones:

# fdisk -l

Disk /dev/sda: 111.8 GiB, 120034123776 bytes, 234441648 sectors

Units: sectors of 1 * 512 = 512 bytes

Sector size (logical/physical): 512 bytes / 512 bytes

I/O size (minimum/optimal): 512 bytes / 512 bytes

Disklabel type: dos

Disk identifier: 0x000bcc1a

Device     Boot Start      End  Sectors Size Id Type

/dev/sda1        2048 62916607 62914560  30G 83 Linux

Cómo podés ver, los cambios sí tuvieron efecto en la partición, pero el tamaño del directorio (filesystem) sigue siendo de 15GB; hace falta redimensionar el filesystem. 

Como podés ver, mi unidad de almacenamiento mide 111.8 (un SSD de 110GB), y la partición ya reporta mis 30GB... pero mi filesystem de root (o sea, el sistema de directorio de root) sigue siendo de 15GB. Debo de extender el tamaño del filesystem; lo hago con esta herramienta: resize2fs.

NOTA: resize2fs redimensiona los filesystems en formato ext2, ext3, ext4. Puede encoger o extender el filesystem si se accede desde fuera del sistema operativo (como una imagen en vivo, por ejemplo, o si tenés el disco duro conectado como "slave" o secundario/adicional en otro equipo); pero si estás corriendo desde el sistema operativo, sólo vas a poder extender el filesystem en cuestión, no encogerlo. A esto se le llama "online resizing", entre otras. Encontré resize2fs en Elementary y Arch; no tuve que instalar nada adicional para usarle.

Vamos entonces a hacer la expansión del filesystem de root, en la partición correspondiente (df -h te dice cuál es la partición correspondiente, recordalo); en mi caso:

# resize2fs /dev/sda1

resize2fs 1.42.13 (17-May-2015)

Filesystem at /dev/sda1 is mounted on /; on-line resizing required

old_desc_blocks = 1, new_desc_blocks = 2

The filesystem on /dev/sda1 is now 7864320 (4k) blocks long. (mensaje de la felicidad :D )

Y confirmo cambios en el tamaño del directorio:

# df -h

Filesystem      Size  Used Avail Use% Mounted on

dev             3.7G     0  3.7G   0% /dev

run             3.7G  508K  3.7G   1% /run

/dev/sda1        30G  3.4G   25G  12% /

tmpfs           3.7G     0  3.7G   0% /dev/shm

tmpfs           3.7G     0  3.7G   0% /sys/fs/cgroup

tmpfs           3.7G     0  3.7G   0% /tmp

tmpfs           742M     0  742M   0% /run/user/0

¡LISTO! ya tenés más espacio en el directorio y partición de root :D :D :D  Ya podés seguir descargando porno y tonterías en tu partición. 

Extender tu partición / (root) sin herramientas gráficas; parte II.

Entonces, ya determinaste cuánto espacio más podés/querés adicionar a tu partición de root. Ahora hay que agregarlo. 

¿Cómo lo hago? fácil; para agregar más espacio a la partición de root, borrás la partición de root. ¿Ah? La borrás y luego la recreás con el nuevo espacio total. Si comenzaba en 7GB y querés que sea de 25GB entonces la recreás con 25GB en total. 

¿Estás seguro? ¿no me voy a cagar en todo? Sí, estoy seguro; y no, no te vas a cagar en todo; todo va a estar bien SI y sólo SI el primer sector de la nueva partición coincide con el primer sector de la nueva partición. 

Ahora, asumo  que vos sos un ser humano responsable y que sabés cómo usar el papel higiénico de forma apropiada y de la misma forma sabés cómo respaldar tus datos... pero como no lo sé con certeza y no me interesa, dejo este disclaimer amigable: yo no soy responsable de cualquier cagada que le hagás a tu equipo. Respaldá tu info primero.

Procedemos: 

# fdisk /dev/sda

Welcome to fdisk (util-linux 2.27.1).

Changes will remain in memory only, until you decide to write them.

Be careful before using the write command.

Command (m for help): d (esto borra la partición)

Selected partition 1

Partition 1 has been deleted.

Command (m for help): n (hacemos la nueva partición)

Partition type

   p   primary (0 primary, 0 extended, 4 free)

   e   extended (container for logical partitions)

Select (default p): p (por supuesto que primaria)

Partition number (1-4, default 1): (la tecla "enter" acepta el valor default)

First sector (2048-234441647, default 2048):  (la tecla "enter" acepta el valor default)

Last sector, +sectors or +size{K,M,G,T,P} (2048-234441647, default 234441647): +30G (el nuevo espacio que quiero; el tuyo puede ser distinto. Si lo querés en megas, usá M y la cantidad apropiada; probablemente tendrás que usar unidades/decenas/centenas de millares)

Created a new partition 1 of type 'Linux' and of size 30 GiB.

Command (m for help): w (escribe y guarda cambios)

The partition table has been altered.

Calling ioctl() to re-read partition table.

Re-reading the partition table failed.: Device or resource busy

(no te asustés, el de arriba es una advertencia lógica y normal)

The kernel still uses the old table. The new table will be used at the next reboot or after you run partprobe(8) or kpartx(8).

# reboot 0 

(es un número cero, significa: reiniciá ya, saltate la cuenta del minuto y medio)

Esto fue lo que hice hace un par de horas. 

Podría explicarte cada línea, pero es extendernos y además, estoy seguro que si te interesa, vas a traducirlas por tu cuenta o usar un traductor. Ya en la otra parte explico cómo concluir esto. 

Extender tu partición / (root) sin herramientas gráficas; parte I.

PARA ENTENDER este artículo, te sugerimos aprender los conceptos de filesystem, directorio, particiones y documentación adicional sobre fdisk.

Si te atreviste a configurar manualmente tus particiones cuando instalaste tu distro, probablemente te preguntaste ¿cuánto espacio necesito para mi partición root? ¿cuántas particiones necesito? ¿cuánto espacio asigno  a una partición swap? 

Todas estas preguntas ya tienen respuesta en las wikis y documentos oficiales de cada distro. Para usuarios expertos, determinar cuánto espacio debe de ser asignado a qué, es fácil. Para los n00bs totales, también porque dejan que los instaladores lo hagan todo por ellos. 

Pero para los que estamos aprendiendo en el ruedo, puede que esas respuestas no nos ayuden totalmente y necesitemos un poco de flexibilidad; tal vez por error o por desconocimiento, asignamos manualmente espacio suficiente para instalar el sistema base y conforme instalamos más paquetes, vemos que nos quedamos sin espacio adicional en la partición, aun teniendo espacio extra en nuestro disco. Si ese sos vos, te explicamos cómo agrandar/estirar/alargar tu partición root vía Terminal, mientras tu sistema operativo está corriendo. A esto se le conoce como LIVE/ONLINE ROOT PARTITION RESIZING o "redimensionamiento de la partición root en vivo/en línea".

PREGUNTA IMPORTANTE ¿por qué habría de usar este método cuando existe Gparted o cuando puedo usar una imagen en vivo desde  un CD/USB? Porque tal vez estás aprendiendo de admiministración de sistemas o corriendo un servidor como en mi caso, o tal vez ya sos un administrador y tenés un servidor de producción al que forzosamente necesitás extenderle el root; o puede que no dispongás de otro sistema o imagen, o simplemente porque sos jarcor (hardcore) y querés aprender a hacerlo sin usar interfaces gráficas (GUIs). Si este es tu caso, seguí leyendo. De otra forma, buscá en línea cómo  usar Gparted, que es más fácil y apropiado para usuarios que no se sienten cómodos trabajando en Terminal porque no tienen el conocimiento y/o no desean aprender a usarla.

RECOMENDACIÓN ANTES DE CORRER UN COMANDO

Usá

$ whatis nombre_del_comando
$ man nombre_del_comando
$ nombre_del_comando --help
$ nombre_del_comando -h

por seguridad y para conocer un poco de ese comando antes de ejecutarlo.

De nada. Felices fiestas :D

mkdir

mkdir se lee "make directory" (se pronuncia algo así: méik diréc-ttri) y sirve para hacer directorios (carpetas o ficheros) en el Sistema de Ficheros de Linux. Su uso es muy simple. Desde tu Terminal:

1. $ pwd
2. $ mkdir testfolder
3. $ ls
4. $ mkdir testfolder/otrotestfolder
5. $ ls
6. $ ls testfolder/
7. $ mkdir testfolder/otrotestfolder/foldercito
8. $ ls
9. $ ls testfolder
10. $ ls testfolder/otrotestfolder
11. $ mkdir testfolder/otrotestfoldermas
12. $ ls testfolder 
13. mkdir /mini-root
14. mkdir /mini-root/root-junior
15. ls / /home

Recordá que si vas a crear un subdirectorio (un directorio adentro de otro directorio), debés de definir la ruta relativa, como mostramos en los pasos 7, 11 y 14 del ejemplo anterior. Como podés ver en los pasos 13 y 14, podés crear un directorio(s) desde otra locación distinta, siempre y cuando usés una ruta absoluta.

En el paso 15 sólo estamos listando dos directorios distintos. Te invito a que pensés en cinco directorios y que los listés todos de forma simultánea.

Hemos usado mkdir  usamos una vez ya, en este artículo para crear un folder donde descargar Screenfetch. Es importante para realizar tareas administrativas vía CLI y también para organizar tus archivos sin recurrir a la GUI. 

Eso es todo por ahora :) 

La importancia de los PPAs en Ubuntu y derivados: el caso Screenfetch.

Hace uno o dos años instalé Screefetch en Luna siguiendo las indicaciones del artículo anterior:

Elementary Luna en mi computadora de escritorio. Nota: el CPU dice "modelo desconocido" porque es uno de esos Phenom II a los que se les pueden activar núcleos dormidos. Pero eso es un tema de hardware y no es relevante.

La cuestión es que para entonces-tenía menos conocimiento y voluntad que los  que tengo ahora y no entendí concientemente la necesidad de agregar un simple PPA a mi Distro vía Terminal (según entiendo, esto puede hacerse vía GUI usando Synaptic; pero no hablaré de eso porque he usado Synaptic muy poco y Terminal es siempre nuestra primera opción). Para un novato, hacer todo esto para instalar un simple programita parecía extraño, incomprensible, poco amigable.

Aquí podría hablar de un dilema de carácter filosófico: a veces las instrucciones de los expertos en la comunidad  son precisas; sin embargo, llegar a ellas  y entenderlas puede ser difícil para un novato; no porque seamos tontos o ignorantes sino porque muchas veces no sabemos qué buscar una vez tenemos los resultados y la info frente a nosotros. Tal vez es que estamos acostumbrados a dar dos clicks para instalar algo, o sólo decirle que "sí" a todo el wizard de instalación; o a lo mejor es que las plataformas de Software Libre son a veces muy  escuetas y muy poco intuitivas (por ejemplo, hay muchos tutoriales que te dicen "escribí este código" pero pocos te describen qué es, qué hace, y por qué lo estás escribiendo). Estoy seguro de que muchos diseñadores UX podría estar de acuerdo conmigo y probablemente los desarrolladores no, puesto que el FOSS ha tenido una población mayoritariamente "tecchy".  

Así que, conectado a mi Banana Pro haciendo sesión remota desde mi laptop, quería saber si era posible generar el logo a pesar de estar conectado en acceso remoto, y qué tipo de logo reportaría Screenfetch para Raspbian, la distro del Banana Pro, puesto que el Banana Pi/Pro tiene un logo distinto al Raspberry Pi. Luego de esta intro aburrida,aquí vamos:

Screenfetch para Ubuntu y derivados.

En fin, al leer las instrucciones con detalle, veo que Brett hace referencia al LaunchPad, que es un repo para PPAs de  Ubuntu y derivados. Este es un tema que ya cubrimos en julio, así que será fácil que sigás con estas instrucciones:

Cuando voy al hipervínculo que sale en el paso 2 de la imagen anterior, soy referido al Launchpad de un usuario en Launchpad, quien parece haber "porteado" Screenfetch hacia los repos de Ubuntu:

Ya con esta información, es suficiente y puedo ponerme a trabajar. Si estás corriendo Ubuntu o derivados (como Freya), vas a tener que escribir dos comandos en tu Terminal:

$ sudo add-apt-repository ppa:djcj/screenfetch

$ sudo apt install screenfetch

En ambos casos se te va a preguntar si querés agregar y permitir instalar. Aceptás y ya. Corrés 

$ screenfetch

y listo. 

Así screenfetch debería de funcionar para usuarios de Ubuntu, ElementaryOS y afines. Sin embargo, no fue así como lo instalé inicialmente durante esta tarde; lo logré con el otro método que te mostré antes; pero repliqué este otro y también funcionó.

Eso es todo por hoy. Compartinos tus Screenshots :)

Screenfetch: información de tu PC, Distro y su logo, en Terminal.

Cuando empezaste a buscar información del FOSS (Free and Open Source Software), o cuando buscabas formas de personalizar tu Distro, seguramente te encontraste con imágenes como esta en los foros:

ElementaryOS Freya (originalmente sería lanzado como Isis, pero debido a los acontecimientos en medio orientese decidió cambiar el nombre). Nótese que desde Luna se empezaron a usar nombres de deidades femininas para cada Versión nueva de Elementary.

Estas capturas de pantalla que los Linuxeros y Unixeros (o sea, usuarios de sistemas operativos Unix, en general) comparten, tienen información de sus Equipos: hardware, sistema operativo y Kernel, junto con el logo renderizado a puros caracteres Unicode (letras, números y símbolos). A lo mejor te preguntaste cómo se hace esto. Simple: buscando, leyendo, aprendiendo, aplicando. Hay varias herramientas que se usan para este objetivo y la más conocida tal vez es ScreenFetch (sedice scriinfetch").

Screenfetch es una herramienta que Brett Bohnenkamper, mejor conocido como el usuario KittyKatt desarrolló y ha puesto a disposición del público en GitHub [un controlador colaborativo de versiones de software que también es usado como Repo].

Screenfetch: instalación general.

 

Las siguientes instrucciones me funcionaron en los siguientes entornos:

•     ElementaryOS Freya en mi laptop.
•     Arch Linux corriendo en VirtualBox adentro de mi laptop con Freya
•     Raspbian en el Banana Pro por medio de sesión remota vía terminal  desde mi laptop.

Con esta muestra, podemos decir que es muy probable que estas instrucciones funcionen en otras Distros, aunque nos hace falta confirmación de parte de alguien que use la familia de RedHat, y otros. Agradeceré que nos compartan los resultados que consigan en sus distros :)

Screenfetch está en la nube de GitHub (una plataforma colaborativa de control de revisiones de Software. Digamos que es un Google Drive para programas, interfaces, código y demás cosas de desarrolladores y programadores).

1) Instalar Git

Como casi cualquier FOSS, Git se integra con Terminal, así que vamos a instalar el comando git para poder luego descargar el Screenfetch a nuestro equipo.

para Ubuntu y afines:

$ sudo apt install git

para Arch y derivados:

$ sudo pacman -Syu git

A partir de acá, podemos instalar de dos formas:

2) Creando un directorio dentro de /home y clonar Screenfetch desde Github:

Hacemos un directorio adentro de "home" (recordá que " ~  " es el home directory)

mkdir ~/screenfetch
cd ~/screenfetch

Recordá usar $ pwd para confirmar que estás en el lugar correcto)  Ahora en él, copiaremos el repo git de Screenfetch adentro de /tmp, así:

$ git clone git://github.com/KittyKatt/screenFetch.git screenfetch

Básicamente, ya tenemos el programa instalado y puesto que lo instalamos en el directorio ~/screenfetch ( o en el /tmp), para poder ejecutar el script desde /home/usuario, tendríamos que escribir

$ sudo screenfetch/screenfetch-dev

2-A) Navegando hacia /temp y clonar Screenfetch desde Github:

En lugar de hacer un nuevo directorio, navegamos hacia el directorio temporal conocido como "/tmp" y proseguir de la misma forma:

$ cd /tmp $ git clone git://github.com/KittyKatt/screenFetch.git screenfetch
$ sudo /tmp/screenfetch/screenfetch-dev

¿Cuál es la diferencia entre ambos métodos?

El primer método requiere generar una nueva entrada en tu filesystem y descargar Screenfetch a ella, mientras que en la segunda, se usa/tmp porque esta es una carpeta de almacenamiento temporal para la sesión: el propósito es que luego de apagar el equipo y reiniciar, la descarga de Screenfetch sea borrada del sistema y evitar así, usar espacio innecesario en el disco. La verdad, es cuestión de preferencia personal. No tengo preferencia, aunque me parece una buena idea el usar /tmp de vez en  cuando.

3)  Ejecutar Screenshot desde su locación: 

Dependiendo del lugar donde lo instalaste, vas a tener que escribir 

$ sudo /tmp/screenfetch/screenfetch-dv

$ sudo ~/screenfetch.

En ambos casos, el comando es demasiado largo y tedioso de escribir. El comando cp copia un directorio o archivo en otra locación, usando esta sintaxis:

$ cp ruta/origen ruta/destino

4)  Copiar el programa, a /usr/bin. 

$ sudo cp screenfetch/screenfetch-dev /usr/bin/screenfetch
$ sudo cp /tmp/screenfetch/screenfetch-dev /usr/bin/screenfetch

La razón por la cual estamos copiando al directorio /usr/bin es porque aquí se alojan los programas y comandos ejecutables por administradores. Por lo tanto, debemos de cambiar permisos para que el usuario regular pueda ejecutar el programa.
 

5) Cambiar permisos:

$ sudo chmod 755 /usr/bin/screenfetch

chmod es "change mode", cambiar modo. Asigna permisos especiales a objetos y elementos en el Filesystem de Unix. y listo. Ahora corré

6) Ejecutar y aplaudir como morsa.

$ screenfetch

Y vas a tener un resultado similar a este:

Screenfetch de Arch Linux. Hemos estado aprendiendo a instalar Arch usando VirtualBox dentro de Freya. Ignorá donde dice "firefox installed", es sólo el nombre de referencia que le di a un snapshot o "captura" de la máquina virtual. Acá estaba corriendo Arch sin GUI; es decir, a pura CLI; en ambos casos Screenfetch funciona porque es un programa de Terminal.

Screenfetch de Arch Linux (vía VirtualBox en Freya) desde un entorno de escritorio que estoy probando

Mientras escribía este artículo en mi laptop corriendo Freya, estaba conectado remotamente vía Terminal a mi servidor de descargas, mi Banana Pro. De nuevo, Screenfetch es una herramienta de Terminal así que le es indiferente si hay interfaz gráfica (Enterno de escritorio o gestor de ventanas); siempre va a darte información de tu sistema.

En la misma página de KittyKatt se encuentran las instrucciones específicas para instalar según cada Distro mayor; Pero para hace uno o dos años, fue un poco difícil de seguirlas debido a mi limitado conocimiento acerca del asunto, y opté por hacerlo como te he compartido en este artículo. Sólo por quitarme la curiosidad y completar el reto, me documenté y logré finalmente instalar Screenfetch en ElementaryOS usando tanto el método que te compartí como las instrucciones dedicadas a Ubuntu por KittyKatt. En la siguiente nota dedico un artículo para usuarios de Ubuntu/derivados.

Pathnames o Rutas.

Definición de Ruta acá. En inglés, path (se pronuncia pæz, con la "zeta" ibérica).

Hay mucho que hablar respecto al Filesystem (sistema de ficheros, carpetas o archivos, en español); tanto que condensar toda la información disponible en una sola nota sería poco amigable; así que hemos descompuesto lo que hemos aprendido en partes más asimilables. Esta es una de ellas. Esperamos que a los amigos principiantes nos sirva mucho. 

Hay dos tipos de rutas (o pathnames) que podés identificar: absolutas y relativas.

• El absolute pathname o ruta absoluta SIEMPRE inicia en el directorio root " / "  y continua rama por rama hasta que alcanza el directorio deseado. Para los principiantes, recomiendo mucho usar rutas absolutas a la hora de navegar en la Terminal, para familiarizarnos con ella y para conocer de mejor forma el Filesystem (sistema de archivos/ficheros):

/home/jose/fotos/fap_folder/oldies

/usr/src/linux/README

/var/log

• Una Relative pathname o ruta relativa inicia en el directorio donde te encontrás en un momento determinado; es decir, NUNCA inicia con " / ". Asumiendo que el usuario está en el directorio /home/jose  el directorio /usr y el directorio /var respectivamente (precisamente por eso son relativas, porque se usan respecto a la posición del usuario en un momento determinado), las rutas realtivas serán:

fotos/fap_folder/oldies

src/linux/README

log

¿La diferencia? Pues que es útil usar rutas absolutas y relativas según la situación. Por ejemplo, si vas a operar dentro de un subdirectorio, usar una ruta relativa te ahorra escribir tooooda la ruta. Por ejemplo, si estás en:

 /home/jose/fotos/fap_folder/oldies/monroe

y querés navegar hacia:

/home/jose/fotos/fap_folder/oldies/greta_garbo

en lugar de escribir:

 $ cd /home/jose/fotos/fap_folder/oldies/greta_garbo

simplemente hacés:

$ cd ../greta_garbo

Recordá que los dos puntos representan al directorio o "rama anterior". Pero a veces usar una ruta absoluta es mucho más conveniente, como cuando estás en:

/home/jose/fotos/fap_folder/oldies/greta_garbo

y querés moverte a:

/usr/tmp 

 Si usás las rutas relativas tendrías que hacer:

$ cd ../../../../../usr/tmp

 lo que implica escribir más. En su lugar es mejor escribir directamente:

$ cd /usr/tmp

Y eso es todo por ahora. Saludos :)

man

Esta es la continuación de los otros dos artículos de la CLI y el sistema de Ficheros.  En esos dos artículos, vimos cómo entender el sistema de ficheros (el filesystem) y cómo navegar en él. Pero eso no es todo. Uno de los comandos más útiels pero subestimados por los amigos de "todoenlatrompa.com", es el comando

man

 $ man comando

Se lee "manual pages" manual para el comando especificado y su uso. Por ejemplo:

$ man pwd
$ man ls
$ man cd
$ man exit
$ man man

¿Para qué me sirve?  Para cuando se te olvida cómo usar un comando o cuando necesitás argumentos o parámetros adicionales para un comando y no recordás cómo usarlos. Por ejemplo, dijimos antes que el comando ls te muestra el contenido de un directorio; pero no te muestra archivos o directorios ocultos. Pero al leer 

$ man ls 

Aprenerás que, existe la opción -l "no ignora elementos comenzando con . (el punto a la izquierda de un archivo o carpeta, significa que ese elemento está "oculto"; si navegás a la GUI, no lo verás. Hay muchos archivos y directorios ocultos por motivos de seguridad, o porque son de configuración y no hace falta que se le muestren al usuario así por así)".

$ ls -a

$ man ls
también nos enseña que

$ ls --author
va a  mostrarnos el autor de cada archivo/carpeta listada en el directorio donde estás.

Entre otras cosas, man nos muestra un número (arriba a la derecha) el tipo de comando que se está corriendo. Te lo recomiendo mucho. Cuando usás man, el prompt ($) desaparece. Esto es porque en esencia, tenés frente a vos a un documento de texto insertado en tu Terminal (por eso los Unixeros te piden  que leás las "man pages")

Apretá "h" para ver las instrucciones/opciones. man usa las mismas instrucciones del comando less, que no veremos hoy por practicidad. Las otras  opciones se ejecutan cuando usás las opciones listadas en la ayuda.  Apretá "q" para salir de la página man en la qu estás; el prompt reaparecerá en el borde inferior de tu Terminal.

Espero que lo usés mucho. Es tu primera fuente de conocimiento y entrenamiento; debe de ser tu ley el leer las man pages antes de preguntarle al prójimo. Te va a ahorrar regaños en los foros y grupos ;)


todoenlatrompa.com: chiste usado para referirse a las personas que todo lo quieren servido y masticado para no tener que hacer su tarea; se deriva del salvadoreñismo: "este maje todo lo quiere en la trompa" = "este bobo todo lo quiere en la boca". El dominio de hecho, existe y tiene un sitio web, aunque no parece tener mayor actualizaciones ni contenido disponibles al público.

CLI y Sistema de Ficheros II

$ pwd

Este es facilito. Se lee "print working directory": imprimir (en pantalla, no en papel) el directorio actual.

$ pwd
muestra/el/directorio/en/el/que/estás/actualmente 

 

$ ls

se lee "list directory", listar directorio:
muestra/los/archivos/o/sub/directorios/del/directorio/especificado

Escribí el siguiente comando en tu Terminal:
$ ls .

El " . " (punto) representa al directorio actual; es decir, el directorio en el que te encontrás. Y esto es algo fascinante si lo pensás: ¿cómo se marca usualmente una posición en un mapa o plano cartesiano? con un punto. Algo tan simple como eso :)

Ahora, seguí uno a uno, los siguientes:

$ ls /
$ ls /etc
$ ls /usr

¿Qué  te dice esto? Que podés navegar por tu PC sin tener que dar click como loco. Pero listar los directorios y  archivos no es suficiente. A veces necesitás moverte; para eso usamos:

 

$ cd 

"Change directory" o cambiar directorio. Hacé esto:

$ pwd

Y ahora, detenidamente hacé esto:

$ cd / 
$ pwd
¿Qué pasó? Te moviste del directorio home (si es que estabas en home), al Root Directory. Ahora escribí:

$ cd - 
$ pwd

Como pudiste notar, " cd - " te regresa al directorio donde estabas inicialmente (no un nivel más o menos, sino al directorio en el que estabas antes).  Hay otros usos de cd:

$ cd .. 
cambia al directorio padre (el directorio que contiene al directorio en el que estás).

$ cd ../..
cambia a dos directorios superiores.

$ cd ../../.. 
cambia tres directorios superiores, y así, hasta que de tanto " .. " vas a llegar al directorio / .

Ejercicio:

(¿Pensaste que no habría ejercicio? Sin repetición no hay aprendizaje duradero. NOTA: a menos que sepás lo que estás haciendo, no vayás a usar otros comandos que aun no hayamos mostrado; esto es por seguridad y  para evitar modificar o agregar cosas a archivos/directorios de forma indebida).  

• Listá el contenido del Root Directory.
• Navegá a /usr
• Imprimí el directorio /usr
• Sin desplazarte a otro lugar, imprimí el directorio /home
• Sin desplazarte a ningún lugar, listá el contenido del directorio /etc
• Navegá a /usr/share/man
• Navegá un nivel hacia atrás
• Listá el contenido de ese nivel donde estás ahora.
• Navegá de vuelta a tu home directory.
• Cerrá tu Terminal.

CLI y Sistema de Ficheros: Dolores de Cabeza para Principiantes.

En palabras de un antiguo samurai: "parecerá difícil al inicio, pero todo es difícil al inicio."

Nos han solicitado que elaboremos una guía un poco "menos técnica" que la que Jimmy compartió hace un rato ya acerca de los comandos básicos así como el asunto del Sistema de Ficheros de Linux. Este es un intento por lograrlo y nos esforzamos por ser lo menos "techy" posible.

La Terminal intimida a mucha gente. Si se la mostrás a un hermano mayor o un papá o tío que haya visto una de las primeras PCs y que no sea un adepto a la informática, a lo mejor te cuente lo complicado que era usar una PC antes;  si sos lo suficientemente viejo tal vez recordás un poco de DOS. Es comprensible; se trata de una pantalla oscura con una rayita que parpadea esperando que le digás qué hacer. Y si no sabés qué palabras usar para decirle qué hacer y escribís cualquier cosa que se te ocurra como "ACM1PT", de seguro te va a escupir un mensaje diciendo algo como "command not recognized" o "comando no reconocido" y es de esperarse que no haga nada y que por lo tanto la PC parezca un alien.

Tal vez por eso es intimidante y la gente le evita; o tal vez porque no quieren tomar el tiempo para aprender a usarla. Pero el problema entonces no es la Terminal, sino nuestro escaso conocimiento acerca del "idioma" que ella "escucha" y "habla". ¿Cómo se arregla este predicamento? De dos formas: huyendo, como la mayoría hace; o aprendiendo a comunicarte en el lenguaje que la Terminal entiende. A todos nos frustró al inicio; pero de nuevo, "todo es difícil al inicio".

Si vas a hacerle frente al problema, armarte de valor y ánimos es sólo una porcioncita de lo que debés de hacer. Se necesita disciplina, orden, dedicación, tiempo, y estar dispuesto a equivocarte una y otra vez. Casi nunca son las felicitaciones las que te hacen aprender para cambiar y mejorar, son tus equivocaciones y cómo vos las tomás. Recordá esto y aplicalo en todo aspecto de tu vida.
 
Es justo y necesario, nuestro deber y salvación aprender los siguientes comandos a usar en Linux. La GUI (Graphical User Interface) no es más que una síntesis o representación visual (en forma de iconos y ventanas) de toda instrucción que tu PC ejecuta. Estas instrucciones pueden ser ingresadas en forma de texto, cosa que con un poco de práctica es más rápida y fácil que dar clicks aquí y allá de un lado a otro de tu pantalla (ahorrándote tiempo, divagación y esfuerzos).

Así como das clicks en tus ventanas para moverte de un lugar a otro en tu PC y lograr que ella haga algo por vos, así también podés desplazarte por tu PC desde una simple ventanita escribiendo texto. 

Vamos a aprender a navegar en tu Terminal con estos comandos básicos. Ellos son como el "AEIOU" de Linux. 

"Pero yo no necesito ni quiero aprender comandos."

Es cierto que para poder hablar no se necesita escribir y que mucha gente vive sin llegar a escribir ni leer nada; pero es cierto que esto les priva de muchas libertades y conocimiento importante para crecer como personas. Algo así sucede con los comandos de la Terminal.

 

Yo sólo quiero ver videos, revisar mi correo y redes sociales.

Bueno, entonces tal vez este no es el lugar para vos y te pediremos que dejés de leer los artículos relacionados a Comandos y Terminal. Lo cierto es que para los usuarios de Linux que deseamos aprovechar el potencial de estos sistemas operativos, la CLI y los comandos son vitales.

¿Qué carajos tienen que ver la Terminal con el Sistema de Ficheros?

Todo. Por ahora digamos que la Terminal es una mezcla de Timón y el Sistema de Ficheros es un Mapa de Navegación. O digamos que tu Terminal es una Caja de Herramientas y tu Sistema de Ficheros es los planos de un Automóvil. Tal vez esta última analogía no la comprendás aún, pero lo harás cuando aprendás comandos avanzado. Si seguiste leyendo, esperamos que esta guía te ayude. Abrí tu Terminal y comencemos. 

$ 

Probablemente es lo primero que vas a ver junto a tu nombre o el nombre que le diste a tu PC cuando instalaste tu distro. Es el "command prompt" o símbolo de sistema. La "señal" que indica estar lista para que ingresés comandos. Cuando veás el prompt en mis tutoriales, deberás escribir los comandos que a su derecha.

# 

Es el mismo símbolo o prompt, pero como "root" o superusuario. A menos que necesités hacer labores de mantenimiento o corrás una distro especializada, vas a ver este prompt muy poco.

 /

Como punto de partida, si alguna ves al símbolo de barra diagonal (símbolo de fracción, pleca, etc.) solito, es que representa al directorio "inicio" o "de partida", llamado Directorio Raíz. O sea, vas a entender que estamos hablando del Root Directory.  Es el nivel primero en el sistema de ficheros y respecto a él, situamos a todos los demás directorios y archivos (aquí no usamos la palabra "raíz" como algo bajo tierra sino como el INICIO, o seal el origen, nacimiento, punto de partida).

Es como si fuera la calle principal de una ciudad y la cual se toma como punto de referencia para poder tomar otras calles y conducirte a tu destino. En dibujitos:

Esta es la representación gráfica de la estructura de directorios de Linux. Recordá que un sistema operativo basado en Linux está organizado en compartimientos llamados conocidos como carpetas/folders/ficheros. En los siguientes niveles ves otros folders/carpetas/nombres. Si partimos de / (el Root Directory) y queremos ubicar al folder "Miguel" dentro del  sistema operativo, vamos a escribir

/home/miguel

que sitúa a Miguel dentro del folder "home", que está dentro del folder o Directorio Root. O sea, podemos decir que Miguel está dos directorios abajo en relación al Root Directory. No estamos diciendo que Miguel tenga menos superpoderes o un Ki menor al del Root Directory por estar "dos niveles abajo", porque no estamos comparando; simplemente estamos situando a Miguel en relación al Root Directory.

Partiendo del directorio Raíz, si queremos representar al fólder public_html, vamos a hacerlo así:

/home/francis/public_html

Como ves, seguimos usando / varias veces; y es que cuando la / se usa después del nombre de un folder, simboliza un "nivel"; o sea, nos sirve para hacer divisiones entre un directorio y otro o un directorio con un archivo. La primera barra a la izquierda simboliza el directorio raíz; las siguientes indican un directorio más "abajo".

  

Notá que escribí 

/home/miguel

y no

/home/Miguel

o

/Home/Miguel

¿Por qué? Porque así es como fueron definidos estos dos directorios y la sintaxis usada en la Terminal es sensible a capitalización. Si no tenés idea qué significa esto, deberías de hacer click en "sensible a capitalización"; he hipervinculado un artículo de la Todopoderosa Wikipedia que te lo explica.

Ya con esta explicación breve, en nuestra Terminal abierta, vamos a escribir este primer comando:

$ exit

¿Qué pasó? Yo sé qué pasó. Seguí la segunda parte para aprender más :)