<!-- 0,1 -->
<!-- Dos to Linux,0 -->
<!-- Guido,Gonzato,guido@ibogfs.df.unibo.it -->
<!-- 1.0,1996-12-11 -->
<!-- Cómo pasar de DOS a Linux -->
<!-- David,Martín Carreño,davefx@bigfoot.com -->
<!-- 1.0,1998-03-08 -->
<!-- DOS,MSDOS -->
<!-- Convivencia,DOS -->

<!doctype linuxdoc system>

<article>
<title>Cómo pasar de DOS a Linux.
<author>Por Guido Gonzato <tt><htmlurl
url="mailto:guido@ibogfs.df.unibo.it" 
name="guido@ibogfs.df.unibo.it"></tt> &nl; Traducido por David Martín
Carreño, <tt><htmlurl url="mailto:davefx@bigfoot.com" 
name="davefx@bigfoot.com"></tt>
<date>v1.0, 11 de diciembre de 1996. Traducción: 8 de marzo de 1998.

<abstract> 
Este documento Como está dedicado a todos los (¿próximamente
anticuados?) usuarios de DOS que acaban de decidir pasarse a Linux, el
clónico gratuito de UNIX para ordenadores x86. Dadas las similitudes
entre DOS y Unix, el propósito de este documento es ayudar al lector a
traducir su conocimiento de DOS al entorno Linux, con todo lo que ello
lleva de productivo. 
</abstract>

<sect>Introducción
<p>

<sect1>¿Es Linux adecuado para usted?
<p>

¿Quiere pasar de DOS a Linux? Buena idea, pero cuidado: puede no serle
útil. Quiero decir: no hay nada que sea <it/el mejor ordenador/ o <it/el
mejor sistema operativo/: depende de a lo que se dedique, por lo que no
creo que Linux sea la mejor solución para todos, incluso aunque sea
técnicamente superior a muchos sistemas operativos comerciales. Usted se
beneficiará inmensamente de Linux si lo que necesita es software para
programar, Internet, TeX... software técnico en general. Pero si necesita
software comercial, o si no le apetece aprender y escribir comandos, deje
Linux y busque en otra parte.

Linux no es (por ahora) tan fácil de usar y configurar como Windows o el
Mac, así que prepárese para trastear un poco. Después de estos avisos,
déjeme decir que confío al 100% en que usted pertenece a la clase de
usuario que encontrará en Linux el Nirvana informático. Está hecho para
usted. Y recuerde que, de todos modos, Linux y DOS/Windows pueden
coexistir en la misma máquina. 

<sect1>Requisitos previos para la lectura de este Como
<p> 

Asumiré que:

<itemize>
<item>conoce los comandos y conceptos básicos del DOS;

<item>Linux, posiblemente con el sistema X Window, está adecuadamente
instalado en su ordenador;

<item>su shell ---el equivalente de <tt/COMMAND.COM/--- es <tt/bash/; 

<item>usted comprende que esta guía es sólo un paso incompleto. Para más
información, busque en el <it/Linux, Instalación y Primeros Pasos/ de Matt
Welsh y en la <it/Guía del Usuario de Linux/ de Larry Greenfield. Ambas,
en versión inglesa, disponibles en <tt><htmlurl
url="ftp://sunsite.unc.edu/pub/Linux/docs/LDP"
name="ftp://sunsite.unc.edu/pub/Linux/docs/LDP"></tt> y, traducidos al
castellano, en la página del proyecto LuCAS: <tt><htmlurl
url="http://www.infor.es/LuCAS"  name="http://www.infor.es/LuCAS"></tt>
</itemize>

<sect1>Ya está. Ahora cuénteme más.
<p>

Supongo que acaba de instalar Linux y los programas que necesita en su
ordenador, que ya tiene una cuenta propia (si no la tiene aún, ¡teclee
<tt>adduser</tt> ahora mismo!) y que Linux está ejecutándose. Acaba de
introducir su nombre y su clave, y ahora está mirando a la pantalla
pensando... <it/¿Y ahora qué?/

Bien, no se desespere. Puede hacer casi las mismas cosas que solía hacer
con DOS, y muchas más. Si estuviera ejecutando DOS en lugar de Linux,
estaría realizando alguna de las siguientes tareas: 

<itemize>
<item>ejecutar programas y crear, copiar, ver, borrar, imprimir, renombrar
ficheros; 

<item>cambiar de directorio, crearlos, borrarlos y listar sus contenidos; 

<item>formatear disquetes y copiar ficheros de/hacia ellos;

<item>editar el <tt/AUTOEXEC.BAT/ y el <tt/CONFIG.SYS/;

<item>escribir sus propios ficheros <tt/.BAT/ y/o programas Qbasic;

<item>el restante 1&percnt;.
</itemize>

Estará contento al saber que todas esas tareas pueden llevarse a cabo bajo
Linux de una manera similar a como se hacen bajo DOS. Bajo DOS, el usuario
medio usa muy pocos de los más de 100 comandos disponibles: lo mismo,
hasta cierto punto, sucede con el Linux.

Unas pocas cosas que señalar antes de continuar:

<itemize>

<item>primero, cómo salir. Para apagar Linux: si ve una pantalla en modo
texto, pulse Ctrl-Alt-Supr, espere a que el sistema realice unas tareas y
le diga que todo está bien, y entonces apague el ordenador. Si está
trabajando bajo el sistema X Window, pulse primero Ctrl-Alt-Del, y
después Ctrl-Alt-Supr. Nunca apague o reinicie el ordenador directamente:
el sistema de ficheros podría dañarse. 

<item>al contrario que en DOS, Linux tiene mecanismos de seguridad
intrínsecos, debido a su naturaleza multiusuario. Los ficheros y los
directorios tienen permisos asociados a ellos, y por lo tanto el usuario
normal puede no tener acceso a alguno de ellos; (ver la Sección <ref
id="Permisos">). Sólo el usuario cuyo nombre de acceso sea <tt/root/
tiene el poder absoluto. (Esta persona es el administrador del sistema. Si
trabaja en un ordenador propio, usted también será root). DOS, por el
contrario le dejaría machacar todos los contenidos de su disco duro. 
 
<item>si está realmente animado a experimentar, inténtelo usted mismo:
seguramente no podrá hacer ningún daño. Puede conseguir alguna ayuda
escribiendo en la línea de comandos (&dollar; es el símbolo de la línea de
comandos estándar, &num; es el de root); 

<tscreen><verb>
$ help
</verb></tscreen>

Esto le porporcionará ayuda acerca de <tt/bash/; puede conseguir
información acerca de un comando concreto escribiendo: 

<tscreen><verb>
$ man comando
</verb></tscreen>

el cual, si tiene instaladas las páginas man, ejecutará la página de
manual <tt/man/ asociada al comando. También puede probar con: 

<tscreen><verb>
$ apropos comando
$ whatis comando
</verb></tscreen>

y presionar <tt/q/ para salir; 

<item>la mayor parte del poder y la flexibilidad de Unix viene de los
conceptos simples de redirección y <it/piping/, o entubamiento, más
potentes que bajo DOS.  Los comandos simples pueden agruparse para
realizar tareas complejas. ¡Use estas características! 

<item><bf/Convenciones/: <tt/&lt;...&gt;/ significa algo que debe ser
especificado, mientras que <tt/[...]/ es algo opcional. Ejemplo: 

<tscreen><verb>
$ tar -tf <fichero.tar> [> fichero_redir]
</verb></tscreen>

<tt/fichero.tar/ debe ser indicado, pero la redirección a
<tt/fichero_redir/ es opcional.

<item>desde ahora <it/LPM/ significa <it/para más información Lea las
Páginas del Manual/.

</itemize>

<sect1>Para el Impaciente
<p>

¿Quiere empezar ya? Eche un vistazo a esto: 

<tscreen><verb>
DOS                     Linux                          Notas

BACKUP                  tar -Mcvf dispositivo dir/     completamente distinto
CD nombredir\           cd nombredir/                  casi la misma sintaxis
COPY fich1 fich2        cp fich1 fich2                 idem
DEL fichero             rm fichero                     cuidado no hay undelete
DELTREE directorio      rm -R directorio/              idem
DIR                     ls                             no exactamente la misma sintaxis
EDIT fichero            vi fichero                     creo que no le gustara
                        emacs fichero                  este es mejor
                        joe fichero                    mas parecido al edit del DOS
FORMAT                  fdformat
                        mount, umount                  sintaxis bastante distinta
HELP comando            man comando                    misma filosofia
MD directorio           mkdir directorio/              casi la misma sintaxis
MOVE fich1 fich2        mv fich1 fich2                 idem
NUL                     /dev/null                      idem
PRINT fichero           lpr fichero                    idem
PRN                     /dev/lp0,
                        /dev/lp1                       idem
RD directorio           rmdir directorio/              idem
REN fich1 fich2         mv fich1 fich2                 no para varios ficheros
RESTORE                 tar -Mxpvf device              sintaxis distinta
TYPE fichero            less fichero                   mucho mejor
WIN                     startx                         ¡mundos aparte!
</verb></tscreen>

Si necesita más que una tabla de comandos, continúe con las secciones
siguientes. 

<sect>Ficheros y Programas

<sect1>Ficheros: Nociones preliminares
<p>

Linux tiene un sistema de ficheros ---la estructura de directorios y los
ficheros que contienen--- muy similar al del DOS. Los ficheros tienen
nombres que obedecen unas normas especiales, están guardados en
directorios y algunos son ejecutables, y entre éstos , la mayoría tiene
opciones en la línea de comandos. Incluso puede utilizar comodines,
redirección y tuberías como en DOS. Sólo hay unas pocas diferencias: 

<itemize> 

<item>bajo DOS, los nombres de ficheros están en el llamado formato 8.3; 
por ejemplo <tt>NOTENOUG.TXT</TT>. Bajo Linux podemos hacerlo mejor. Si
instaló Linux usando un sistema de ficheros tal como <it/ext2/ o
<it/umsdos/, puede utilizar nombres más largos (hasta 255 caracteres), y
con más de un punto en ellos: por ejemplo,
<tt>Este.es.un.nombre.de.fichero.MUY.largo</TT>.  Dése cuenta de que he
utilizado tanto mayúsculas como minúsculas: en efecto... 
 
<item>Linux es sensible a las mayúsculas y las minúsculas en los nombres
de ficheros o comandos. De hecho, <tt/FICHERO.tar.gz/ ,
<tt/Fichero.tar.gz/ y <tt/fichero.tar.gz/ son tres ficheros distintos.
<tt/ls/ es un comando, <tt/LS/ sería un error; 

<item>no hay extensiones obligadas como <tt/.COM/ y <tt/.EXE/ para los
programas, o <tt/.BAT/ para los ficheros de procesamiento por lotes. Los
ficheros ejecutables se marcan con un asterisco. Por ejemplo: 

<tscreen><verb>
$ ls -F
cindy.jpg    cjpg*    Soy_un_directorio/  mi_1er_script*  old~
</verb></tscreen>

Los ficheros <tt>cjpg*</tt> y <tt>mi_1er_script*</tt> son "programas" 
ejecutables. Bajo DOS, las copias de seguridad de los ficheros suelen
acabar en <tt/.BAK/, mientras que bajo Linux acaban con un gurruño
&tilde;. Un fichero cuyo nombre empieza con un punto es considerado como
oculto. Ejemplo: el fichero <tt/.Soy.un.fichero.oculto/ no se mostrará
a un comando <tt/ls/; 

<item>Las opciones de los programas bajo DOS se obtienen con
<tt>/opción</tt>. En Linux se obtienen con <tt/-opción/ o <tt/--opción/. 
Ejemplo: <tt>dir /s</tt> se convierte en <tt>ls -R</tt>. Fíjese en que
muchos programas DOS (como <tt/PKZIP/ o <tt/ARJ/) utilizan opciones de
tipo Unix.

</itemize>

Puede ahora saltar a las Sección <ref id="Traduciendo">, pero yo de usted
seguiría leyendo.

<sect1>Enlaces simbólicos
<p>

Unix tiene un tipo de fichero que no existe bajo DOS: el enlace simbólico. 
Puede pensar que es un puntero o enlace a un fichero o a un directorio y
que puede utilizarse en lugar del fichero o del directorio al que apunta;
es similar a los "Accesos Directos" de Windows 95. Ejemplos de enlaces
simbólicos son <tt>/usr/X11</tt>, que apunta a <tt>/usr/X11R6</tt>; 
<tt>/dev/modem</tt>, que apunta a <tt>/dev/cua0</tt> o a
<tt>/dev/cua1</tt>, según donde esté el módem.

Para crear un enlace simbólico:

<tscreen><verb>
$ ln -s <fichero_o_directorio> <nombre_del_enlace>
</verb></tscreen>

Ejemplo:

<tscreen><verb>
$ ln -s /usr/doc/g77/DOC g77manual.txt
</verb></tscreen>

Ahora puede referirse a <tt/g77manual.txt/ en lugar de
<tt>/usr/doc/g77/DOC</tt>. 

<sect1>Permisos y Propiedades<label id="Permisos">
<p>

Los ficheros y directorios de DOS tienen los siguientes atributos: <tt/A/
(fichero), <tt/H/ (oculto), <tt/R/ (sólo-lectura), y <tt/S/ (sistema). 
Sólo <tt/H/ y <tt/R/ tienen sentido bajo Linux: los ficheros ocultos
comienzan con un punto, y los de sólo lectura, tienen activado el permiso
"<tt/r/". 

Bajo Unix un fichero tiene <it/permisos/ y un propietario, que pertenece a
un grupo. Mire este ejemplo:

<tscreen><verb>
$ ls -l /bin/ls
-rwxr-xr-x  1  root  bin  27281 Aug 15 1995 /bin/ls*
</verb></tscreen>

El primer campo contiene los permisos del fichero <tt>/bin/ls</tt>, que
pertenece a <tt/root/, del grupo <tt/bin/. Dejando la información restante
a un lado (el libro de Matt esta ahí para ese propósito), sólo recordaré
lo que significa <tt/-rwxr-xr-x/ (de izquierda a derecha):

<tt/-/ es el tipo de fichero (<tt/-/ = fichero normal, <tt/d/ =
directorio, <tt/l/ = enlace, etc.); <tt/rwx/ son los permisos del
propietario del fichero (leer, escribir, ejecutar); <tt/r-x/ son los
permisos para el grupo del propietario del fichero (leer y ejecutar); (no
tocaré el concepto de grupo, puede pasar sin él mientras sea un novato ;-) 
<tt/r-x/ son los permisos para todos los demás usuarios (leer, ejecutar).

A eso se debe el porqué no puede borrar el fichero <tt>/bin/ls</tt> a
menos que sea root:  no tiene el permiso de escritura para hacer eso. Para
cambiar los permisos de un fichero, el comando es: 

<tscreen><verb>	
$ chmod <quienXperm> <fichero>
</verb></tscreen>

donde <tt/quien/ podría ser:

<itemize>
<item><tt/u/ usuario, que es el propietario,
<item><tt/g/ (grupo), 
<item><tt/o/ (otros).
</itemize>

<tt/X/ puede ser tanto <tt/+/ como <tt/-/, y  <tt/perm/ puede ser:

<itemize>
<item><tt/r/ (lectura), 
<item><tt/w/ (escritura)
<item><tt/x/ (ejecución). 
</itemize>

Ejemplos: 

<tscreen><verb>
$ chmod u+x fichero
</verb></tscreen>

esto habilita el permiso de ejecución para el propietario del fichero.
Atajo: <tt/chmod +x fichero/. 

<tscreen><verb/
$ chmod go-wx fichero/
</tscreen>

esto quita el permiso de escritura y de ejecución para todo el mundo menos
al usuario. 

<tscreen><verb>
$ chmod ugo+rwx fichero
</verb></tscreen>

esto le da a todo el mundo el permiso de lectura, escritura y ejecución. 

<tscreen><verb>
$ chmod +s fichero
</verb></tscreen>

esto convierte al fichero en <it/setuid/ o <it/suid/, esto es, un fichero
que al ejecutarse lo hace con privilegios de root. 

Una manera más corta de referirse a los permisos es con números: 
<tt/rwxr-xr-x/ puede ser expresado como <tt/755/ (cada letra corresponde a
un bit: <tt/---/ es <tt/0/, <tt/--x/ es <tt/1/, <tt/-w-/ es <tt/2/,
<tt/-wx/ es <tt/3/...). Parece difícil, pero con algo de práctica el
concepto se domina.

<tt/root/, al ser superusuario, puede cambiar los permisos de los ficheros
de todo el mundo. Hay mucha más información acerca de esto:  LPM. 

<sect1>Traduciendo comandos de DOS a Linux<label id="Traduciendo">
<p>

A la izquierda, los comandos de DOS; a la derecha, sus correspondientes de
Linux. 

<tscreen><verb>
COPY:         cp
DEL:          rm
MOVE:         mv
REN:          mv
TYPE:         more, less, cat
</verb></tscreen>

Operadores de redirección y de tuberías: 

<tt>&lt; &gt; &gt;&gt;  &verbar;</tt>

Comodines: <tt>* ?</tt>

<tscreen><verb>
nul: /dev/null

prn, lpt1:  /dev/lp0 o /dev/lp1; lpr
</verb></tscreen>

EJEMPLOS

<tscreen><verb>
DOS                                     Linux
---------------------------------------------------------------------

C:\GUIDO>copy joe.txt joe.doc           $ cp joe.txt joe.doc
C:\GUIDO>copy *.* total                 $ cat * > total
C:\GUIDO>copy fractals.doc prn          $ lpr fractals.doc
C:\GUIDO>del temp                       $ rm temp
C:\GUIDO>del *.bak                      $ rm *~
C:\GUIDO>move paper.txt tmp\            $ mv paper.txt tmp/
C:\GUIDO>ren paper.txt paper.asc        $ mv paper.txt paper.asc
C:\GUIDO>print letter.txt               $ lpr letter.txt
C:\GUIDO>type letter.txt                $ more letter.txt
C:\GUIDO>type letter.txt                $ less letter.txt
       idem                             $ more *.txt *.asc
       idem                             $ cat section*.txt | less
C:\GUIDO>type letter.txt > nul          $ cat letter.txt > /dev/null
</verb></tscreen>
Notas:

<itemize>

<item><tt/*/ es más inteligente bajo Linux: <tt/*/ equivale a todos los
ficheros excepto los ocultos; <tt/.*/ equivale a todos los ficheros
ocultos;  <tt/*.*/ equivale sólo a aquellos ficheros que tienen un punto
en medio del nombre, seguido de otros caracteres; <tt/p*r/ equivaldría
tanto a <tt/peor/ como a <tt/por/;  <tt/*c*/ equivaldría tanto a
<tt/pecado/ como a <tt/peca/. 

<item>cuando se usa <tt/more/, pulse espacio para ir leyendo a través del
fichero, <tt/q/ o Ctrl-C para salir. <tt/less/ es más intuitivo y permite
utilizar las teclas del cursor;

<item>no hay <tt/UNDELETE/, así que piénselo dos veces antes de borrar
cualquier cosa;

<item>además de los &lt; &gt; &gt;&gt; del DOS, Linux tiene el operador
<tt/2&gt;/ para redirigir los mensajes de error (stderr); más aún, el
operador <tt/2&gt;&amp;1/ redirige stderr a stdout (la salida estándar),
mientras que <tt/1&gt;&amp;2/ redirige stdout a stderr;

<item>Linux tiene otro comodín: los corchetes <tt/[]/. Usar <tt/[abc]*/
equivale a los ficheros que empiezan por <tt/a/, por <tt/b/ o por <tt/c/; 
<tt/*[I-N,1,2,3]/ equivale a los ficheros que acaban por <tt/I, J, K, L,
M, N, 1, 2, 3/;

<item>no hay un <tt/RENAME/ como en DOS; esto es, <tt/mv *.xxx *.yyy/ no
funciona;

<item>use <tt/cp -i/ y <tt/mv -i/ para ser avisado cuando un fichero vaya
a ser sobreescrito. 
</itemize>

<sect1>Ejecución de programas: Multitarea y Sesiones
<p>

Para ejecutar un programa, escriba su nombre tal y como lo haría bajo DOS. 
Si el directorio (Sección <ref id="Directorios">) donde el programa está
guardado está incluido en la variable de entorno <tt/PATH/ (Sección <ref
id="Inicializacion">), el programa comenzará a ejecutarse. Excepción: al
contrario que bajo DOS, en Linux un programa localizado en el directorio
actual no se ejecutará a manos que el directorio actual (simbolizado por
``<tt/./'') esté incluido en el PATH. Para evitarlo, suponiendo que el
programa se llame <tt/prog/, teclee <tt>./prog</tt>.

Éste es el aspecto típico de una línea de comandos:

<tscreen><verb>
$ comando -o1 -o2 ... -on par1 par2 ... parn  < input > output
</verb></tscreen>

donde <tt/-o1/, ..., <tt/-on/ son las opciones del programa, <tt/par1/,
..., <tt/parn/ son los parámetros del programa. Puede encadenar varios
comandos en la línea de comandos: 

<tscreen><verb>
$ comando1 ; comando2 ; ... ; comandoN
</verb></tscreen>

Esto es todo acerca de ejecutar comandos, pero es fácil ir un paso más
allá. Una de las principales razones para usar Linux es que es un sistema
operativo multitarea ---puede ejecutar varios programas (a partir de
ahora, procesos) a la vez---. Puede lanzar procesos en segundo plano
(<it/background/)  y seguir trabajando inmediatamente. Más aún, Linux
permite tener varias sesiones abiertas simultáneamente: es como tener
muchos ordenadores en los que trabajar a la vez. 

<itemize>
<item>Para cambiar a la sesión 1..6:

<tscreen><verb>
$ Alt-F1 ... Alt-F6
</verb></tscreen>

<item>Para comenzar una nueva sesión sin dejar la actual:

<tscreen><verb>
$ su - <mi_nombre_de_usuario>
</verb></tscreen>

Ejemplo:

<tscreen><verb/
$ su - root/
</tscreen>

Esto es útil, por ejemplo, cuando se necesita montar un disco (Sección
<ref id="Disquetes">): normalmente, sólo <tt/root/ puede hacer eso. 

<item>Para acabar una sesión:

<tscreen><verb>
$ exit
</verb></tscreen>

Si hay trabajos parados (ver más abajo), será avisado.

<item>Para lanzar un proceso en primer plano:

<tscreen><verb>
$ nomprog [-opciones] [parametros] [< input] [> output]
</verb></tscreen>

<item>Para lanzar un proceso en segundo plano, añada un <it/ampersand/:
<tt/&amp;/, al final de la línea de comandos:

<tscreen><verb>
$ nomprog [-opciones] [parametros] [< input] [> output] &
[1] 123
</verb></tscreen>

el shell o intérprete de comandos identifica el proceso con un número de
trabajo (p.e. [1]; ver más abajo), y con un PID (123 en nuestro ejemplo).

<item>Para ver cuántos procesos hay:

<tscreen><verb>
$ ps -a
</verb></tscreen>

Esto generará una lista de procesos actualmente en ejecución.

<item>Para matar un proceso:

<tscreen><verb>
$ kill <PID>
</verb></tscreen>

Puede necesitar matar un proceso cuando no sabe cómo cerrarlo de la manera
correcta... ;-). A veces, un proceso solo podrá ser matado con alguna de
las siguientes instrucciones:

<tscreen><verb>
$ kill -15 <PID>
$ kill -9 <PID>
</verb></tscreen>
</itemize>

Además, el intérprete de comandos permite suspender temporalmente (parar) 
un proceso, mandar un proceso al segundo plano, y traer un proceso del
segundo plano al primer plano. En este contexto, los procesos son
denominados <it/trabajos/. 

<itemize>
<item>Para ver cuántos trabajos hay:

<tscreen><verb>
$ jobs
</verb></tscreen>

aquí los trabajos son identificados por su número de trabajo, no por su
PID. 

<item>Para parar un proceso ejecutándose en primer plano (no siempre
funciona): 

<tscreen><verb>
$ Ctrl-C
</verb></tscreen>

<item>Para suspender un proceso ejecutándose en primer plano:

<tscreen><verb>
$ Ctrl-Z
</verb></tscreen>

<item>Para mandar un proceso suspendido al segundo plano (convirtiéndolo
en trabajo): 

<tscreen><verb>
$ bg <trabajo>
</verb></tscreen>

<item>Para traer un trabajo al primer plano:

<tscreen><verb>
$ fg <trabajo>
</verb></tscreen>

<item>Para matar un trabajo:

<tscreen><verb>
$ kill <%trabajo>
</verb></tscreen>

donde <tt/trabajo/ puede ser 1, 2, 3; el <tt/&percnt;/ indica que nos
referimos a un número de trabajo, y no a un PID. Usando estos comandos
puede formatear un disco, comprimir un puñado de ficheros, compilar un
programa, y descomprimir un fichero simultáneamente, y todavía tener la
línea de comandos a su disposición. Inténtelo con el DOS. Inténtelo con
Windows, sólo para ver la diferencia de prestaciones (siempre que no se le
cuelgue, claro). 

</itemize>

<sect1>Ejecutando Programas en Ordenadores Remotos
<p>

Para ejecutar un programa en una máquina remota cuya dirección IP es
<tt/remote.bigone.edu/, teclee: 

<tscreen><verb>
$ slogin remote.bigone.edu -l <login_en_maquina_remota>
</verb></tscreen>

Tras meter su password, arranque su programa favorito. Obviamente, debe
tener una cuenta en la máquina remota. 

Si tiene X11, puede incluso ejecutar una aplicación X en un ordenador
remoto, mostrándolo en su pantalla de X. Supongamos <tt/remote.bigone.edu/
la máquina X remota y <tt/local.linux.box/ su máquina Linux. Para ejecutar
desde <tt/local.linux.box/ un programa X que reside en
<tt/remote.bigone.edu/, haga lo siguiente: 

<itemize>

<item>arranque las X, arranque un xterm o un emulador de terminal
equivalente, y entonces teclee: 

<tscreen><verb>
$ xhost +remote.bigone.edu
$ slogin remote.bigone.edu -l <login_en_maquina_remota>
</verb></tscreen>

<item>tras meter su password, teclee:

<tscreen><verb>
remote:$ DISPLAY=local.linux.box:0.0
remote:$ programa &
</verb></tscreen>

(en vez de <tt/DISPLAY.../, puede que tenga que escribir <tt/setenv
DISPLAY local.linux.box:0.0/. Depende del shell remoto). 

</itemize>

Ahora <tt/programa/ comenzará en <tt/remote.bigone.edu/ y se mostrará en
su máquina. Aunque mejor no intente esto en una línea ppp.

<sect>Gestión de Directorios<label id="Directorios">
<p>

<sect1>Directorios: Nociones preliminares
<p>

Hemos visto las diferencias entre los ficheros de DOS y Linux. Entre
directorios, bajo DOS el directorio raíz es <tt/&bsol;/ y bajo Linux es
<tt>/</tt> . De manera similar, los directorios anidados se separan
mediante <tt/&bsol;/ en DOS y mediante <tt>/</tt> en Linux. Ejemplo de
rutas de fichero: 

DOS:    <tt/C:&bsol;PAPERS&bsol;GEOLOGY&bsol;MID_EOC.TEX/

Linux:  <tt>/home/guido/papers/geology/mid_eocene.tex</tt>

Como bajo DOS, <tt/../ es el directorio padre y <tt/./ es el directorio
actual.  Recuerde que el sistema no le dejará hacer <tt/cd/, <tt/rd/ o
<tt/md/ donde usted quiera. Cada usuario comienza desde su propio
directorio llamado <tt>&tilde;/</tt>. En el ejemplo anterior, éste es
<tt>/home/guido</tt>. 

<sect1> Permisos en los directorios.
<p>

Los directorios también tienen permisos. Lo que hemos visto en la Sección
<ref id="Permisos"> también rige para los directorios (usuario, grupo, y
otros). Para un directorio, <tt/rx/ significa que puede cambiar a ese
directorio, y <tt/w/ significa que puede crear o borrar ficheros en el
directorio (según los permisos de los ficheros, por supuesto), o el
directorio mismo. 

Por ejemplo, para prevenir que otros usuarios husmeen en
<tt>/home/guido/text</tt>: 

<tscreen><verb>
$ chmod o-rwx /home/guido/text
</verb></tscreen>

<sect1>Equivalencia de comandos de DOS a Linux
<p>

<tscreen><verb>
DIR:            ls, find, du
CD:             cd, pwd
MD:             mkdir
RD:             rmdir
DELTREE:        rm -R
MOVE:           mv
</verb></tscreen>

EJEMPLOS

<tscreen><verb>
DOS                                     Linux
---------------------------------------------------------------------

C:\GUIDO>dir                            $ ls
C:\GUIDO>dir file.txt                   $ ls file.txt
C:\GUIDO>dir *.h *.c                    $ ls *.h *.c
C:\GUIDO>dir/p                          $ ls | more
C:\GUIDO>dir/a                          $ ls -l
C:\GUIDO>dir *.tmp /s                   $ find / -name "*.tmp"
C:\GUIDO>cd                             $ pwd
        n/a - ver nota                  $ cd
        idem                            $ cd ~
        idem                            $ cd ~/temp
C:\GUIDO>cd \otros                      $ cd /otros
C:\GUIDO>cd ..\temp\trash               $ cd ../temp/trash
C:\GUIDO>md newprogs                    $ mkdir newprogs
C:\GUIDO>move prog ..                   $ mv prog ..
C:\GUIDO>md \progs\turbo                $ mkdir /progs/turbo
C:\GUIDO>deltree temp\trash             $ rm -R temp/trash
C:\GUIDO>rd newprogs                    $ rmdir newprogs
C:\GUIDO>rd \progs\turbo                $ rmdir /progs/turbo
</verb></tscreen>

Notas:

<enum>

<item> cuando se use <tt/rmdir/, el directorio a borrar debe estar vacío.
Para borrar un directorio y todos sus contenidos, use <tt/rm -R/ (bajo su
propia responsabilidad). 

<item> el carácter <tt/&tilde;/ es un atajo para el nombre de su
directorio de usuario. Los comandos <tt/cd/ o <tt/cd &tilde;/ le llevarán
a su directorio personal desde dondequiera que esté; el comando <tt>cd
&tilde;/tmp</tt> le llevará a <tt>/home/su_directorio_de_usuario/tmp</tt>. 

<item><tt/cd -/ "deshace" el último cd.
</enum>

<sect>Disquetes, discos duros y otros métodos de almacenamiento.<label
id="Disquetes">
<p>

<sect1>Administración de dispositivos
<p>

Nunca habrá pensado acerca de ello, pero el comando de DOS <tt/FORMAT A:/
hace mucho más de lo que parece. De hecho, cuando ordene el comando
<tt/FORMAT/: 

<enum>
<item>Formateará físicamente el disco
<item>Creará el directorio <tt/A:/ (creará un sistema de ficheros)
<item>Pondrá el disco disponible para el usuario (montará el disco).
</enum>

Estos tres pasos se ordenan separadamente bajo Linux. Puede usar disquetes
con formato MS-DOS, aunque haya otros formatos disponibles y sean mejores
(el formato MS-DOS no le dejará usar nombres de fichero largos). A
continuación se explica cómo preparar un disco (necesitará iniciar una
sesión como root): 

<itemize>
<item>Para formatear un disquete estándar de 1.44 megas (A:):

<tscreen><verb>
# fdformat /dev/fd0H1440
</verb></tscreen>

<item>Para crear un sistema de ficheros:

<tscreen><verb>
# mkfs -t ext2 -c /dev/fd0H1440
</verb></tscreen>

o para crear un sistema de ficheros MS-DOS:

<tscreen><verb>
# mformat a:
</verb></tscreen>

Antes de usar el disco, debe montarlo.

<item>Para montar el disco:

<tscreen><verb>
# mount -t ext2 /dev/fd0 /mnt
</verb></tscreen>

o

<tscreen><verb>
# mount -t msdos /dev/fd0 /mnt
</verb></tscreen>

Ahora puede dirigirse a los ficheros del disquete. Cuando haya acabado,
antes de sacar el disco deberá desmontarlo. 

<item>Para desmontar el disco:

<tscreen><verb>
# umount /mnt
</verb></tscreen>

Ahora puede extraer el disco. Obviamente, debe hacer un <tt/fdformat/ y un
<tt/mkfs/ sólo a los discos no formateados, que no han sido usados nunca. 
Si quiere utilizar la unidad B:, ponga <tt/fd1H1440/ y <tt/fd1/ en lugar
de <tt/fd0H1440/ y <tt/fd0/ en los ejemplos anteriores. 
</itemize>

Todo lo que solía hacer con A: y B: se hace ahora utilizando <tt>/mnt</tt>
en su lugar.  Ejemplos: 

<tscreen><verb>
DOS                                     Linux
--------------------------------------------------------------------

C:\GUIDO>dir a:                         $ ls /mnt
C:\GUIDO>copy a:*.*                     $ cp /mnt/* /docs/temp
C:\GUIDO>copy *.zip a:                  $ cp *.zip /mnt/zip
C:\GUIDO>a:                             $ cd /mnt
A:>_                                    /mnt/$ _
</verb></tscreen>

No hace falta decir que la manera de proceder con los disquetes también
funciona con otros dispositivos, como por ejemplo, otro disco duro o una
unidad CD-ROM. Esto es para montar el CD-ROM: 

<tscreen><verb>
# mount -t iso9660 /dev/cdrom /mnt
</verb></tscreen>

Ésta era la manera ``oficial'' de montar discos, pero hay un truco. Como
es algo incómodo tener que ser root para montar un disquete o un CD-ROM,
puede darse permisos a cada usuario de esta manera:

<itemize>

<item>como root, crear los directorios <tt>/mnt/floppy</tt>,
<tt>mnt/a:</tt>, y <tt>/mnt/cdrom</tt>
 
<item>añadir en <tt>/etc/fstab</tt> las siguientes líneas:

<tscreen><verb>
/dev/cdrom        /mnt/cdrom    iso9660   ro,user,noauto          0       0
/dev/fd0          /mnt/a:       msdos     user,noauto             0       0
/dev/fd0          /mnt/floppy   ext2      user,noauto             0       0
</verb></tscreen>
</itemize>

Ahora, para montar un disquete MS-DOS, un disquete ext2, y un CD-ROM:

<tscreen><verb>
$ mount /mnt/a:
$ mount /mnt/floppy
$ mount /mnt/cdrom
</verb></tscreen>

Cualquier usuario puede acceder a <tt>/mnt/floppy</tt>, <tt>/mnt/a:</tt>,
y <tt>/mnt/cdrom</tt>. Para escribir en <tt>/mnt/floppy</tt> sin ser root,
después de preparar el floppy es necesario hacer: 

<tscreen><verb>
# mount /mnt/floppy
# chmod 777 /mnt/floppy
# umount /mnt/floppy
</verb></tscreen>

Recuerde que si considera importante la seguridad, dejar que todo el mundo
pueda montar discos de esta manera constituye un buen agujero en la misma. 

<sect1>Copias de Seguridad
<p>

Ahora que sabe cómo se manejan disquetes, etc. un par de líneas bastan
para ver cómo hacer una copia de seguridad. Hay muchos paquetes que pueden
servirle, pero lo más simple para hacer una copia de seguridad
multivolumen (como root) es: 

<tscreen><verb>
# tar -M -cvf /dev/fd0H1440 /directorio_a_guardar
</verb></tscreen >

Asegúrese de tener un disquete formateado en la unidad, y otros ya
preparados. Para restaurar sus ficheros, inserte el primer disquete en la
unidad y utilice: 

<tscreen><verb>
# tar -M -xpvf /dev/fd0H1440
</verb></tscreen>

<sect>Personalización del Sistema
<p>

<sect1>Ficheros de inicialización del sistema<label id="Inicializacion">
<p>

Dos ficheros importantes bajo DOS son el <tt/AUTOEXEC.BAT/ y el
<tt/CONFIG.SYS/, los cuales se utilizan al rearrancar el sistema para
inicializarlo, dar valores a algunas variables de entorno como <tt/PATH/ y
<tt/FILES/, y posiblemente lanzar un programa o fichero de procesamiento
por lotes. Bajo Linux hay varios ficheros de inicialización, algunos de
los cuales no deberían ser modificados hasta que usted supiese con
seguridad lo que está haciendo. De todos modos, estos son los más
importantes: 

<tscreen><verb>
FICHEROS             NOTAS
/etc/inittab         ¡no tocar por ahora!
/etc/rc.d/*          idem
</verb></tscreen>

Si todo lo que necesita es establecer el <tt/PATH/ y otras variables de
entorno, o desea cambiar los mensajes del login o ejecutar automáticamente
un programa tras iniciar una sesión, eche un vistazo a los siguientes
ficheros: 

<tscreen><verb>
FICHEROS                        NOTAS
/etc/issue                      establece el mensaje de antes del login
/etc/motd                       establece el mensaje de despues del login
/etc/profile                    establece el PATH y otras variables, etc.
/etc/bashrc                     define alias y funciones, etc. (ver mas abajo)
/home/su_home/.bashrc           define sus alias y sus funciones
/home/su_home/.bash_profile     establece el entorno y ejecuta sus programas
/home/su_home/.profile          idem
</verb></tscreen>

Si el último fichero existe (fíjese en que es un fichero oculto), se leerá
tras el inicio de sesión y se ejecutarán los comandos en él almacenados.

Ejemplo; mire este <tt/.profile/:

<tscreen><verb>
# Soy un comentario
echo Entorno:
printenv | less   # equivalente del comando SET bajo DOS
alias d='ls -l'   # es facil comprender lo que es un alias
alias up='cd ..'
echo "Recuerde que su path es "$PATH
echo "Hoy es `date`"  # usa la salida del comando 'date'
echo "Que tenga un buen dia, "$LOGNAME
# Lo siguiente es una funcion del shell
ctgz() # Lista los contenidos de un fichero .tar.gz 
{
  for file in $*
  do
    gzip -dc ${file} | tar tf -
  done
}
# fin de .profile
</verb></tscreen>

<tt/PATH/ y <tt/LOGNAME/, lo adivinó, son variables de entorno. Hay muchas
otras accesibles; para buscar ejemplos, LPM de aplicaciones como
<tt/less/.

<sect>Ficheros de Inicialización de Programas
<p>

Bajo Linux, casi todo puede ser configurado de acuerdo con sus
necesidades. La mayoría de los programas tienen uno o más ficheros de
inicialización con los que puede trastear, a menudo llamados
<tt/.nombreprogramarc/, situados en su directorio <tt/home/. Los primeros
que querrá modificar son los de configuración del gestor de ventanas para
X-Window.  Si utiliza el <tt/fvwm2/ serán:

<tscreen><verb>
/usr/X11/lib/X11/fvwm2/system.fvwmrc2 
</verb></tscreen>

Para el resto de programas con el que se encontrará tarde o temprano, LPM. 

<sect>Un poco de Programación
<p>

<sect1>Los Scripts del Shell: Ficheros <tt>.BAT</tt> con esteroides
<p>

Si ha utilizado ficheros <tt/.BAT/ para crear atajos de largas líneas de
comando (yo suelo hacerlo), el objetivo puede ser obtenido insertando las
líneas de alias convenientes (ver ejemplo de más arriba) en el
<tt/profile/ o en el <tt/.profile/. Pero si sus ficheros <tt/.BAT/ son más
complicados, le encantará el lenguaje de Script que el shell pone a su
disposición: es tan potente como el Qbasic (o más). Tiene variables,
estructuras como <tt/while/, <tt/for/, <tt/case/, <tt/if-then-else/, y
montones de nuevas características: puede ser una buena alternativa a un
lenguaje de programación "de verdad". 

Para escribir un script ---el equivalente a un fichero <tt/.BAT/ bajo DOS---
todo lo que tiene que hacer es escribir un fichero ASCII estándar que
contenga las instrucciones, guardarlo, y entonces hacerlo ejecutable con
el comando <tt>chmod +x fichero</tt>. Para ejecutarlo, teclee su nombre. 

Aviso: el editor del sistema se llama <tt/vi/, y es un hecho probado que
la mayor parte de los nuevos usuarios lo encuentran muy difícil de usar. 
No voy a explicar cómo usarlo, porque no me gusta y no lo uso. Vea el
manual "<it/Linux: Instalación y Primeros Pasos/" de Matt Welsh (aunque sería
mejor utilizar otro editor tal como <tt>joe</tt> o <tt/emacs/ para X).
Baste decir aquí unos comandos muy básicos: 

<itemize>
<item>para insertar texto, pulse <tt/i/ y después el texto;

<item>para salir de <tt/vi/ sin guardar, pulse <tt/ESC/ y después <tt/:q!/

<item>para guardar y salir, pulse <tt/ESC/ y luego <tt/:wq/
</itemize>

Escribir scripts bajo bash es una materia tan extensa que requeriría un
libro para abarcarla toda, y no voy a profundizar más allá en este tema.
Sólo daré un ejemplo de script, del cual se pueden extraer las reglas
básicas: 

<tscreen><verb>
#!/bin/sh
# ejemplo.sh
# Soy un comentario
# no cambie la primera linea: debe estar ahi
echo "Este sistema es: `uname -a`" # usa la salida del comando
echo "Me llamo $0" # variables intrinsecas
echo "Usted me dio $# parametros: "$*
echo "El primer parametro es: "$1
echo -n "¿Como se llama? " ; read su_nombre
echo fijese en la diferencia: "Hola, $su_nombre" # entrecomillando con "
echo fijese en la diferencia: 'Hola, $su_nombre' # entrecomillando con '
DIRS=0 ; FILES=0
for fichero in `ls .` ; do
  if [ -d ${fichero} ] ; then # si el fichero esta en el directorio
    DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1
  else if [ -f ${fichero} ] ; then
   FILES=`expr $FILES + 1`
  fi
  case ${fichero} in
    gif|*jpg) echo "${fichero}: fichero grafico" ;;
    *.txt|*.tex) echo "${fichero}: fichero de texto" ;;
    *.c|*.f|*.for) echo "${fichero}: fichero de codigo fuente" ;;
    *) echo "${fichero}: fichero generico" ;;
  esac
done
echo "Hay ${DIRS} directorios y ${FILES} ficheros"
ls | grep "ZxY--!!!WKW"
if [ $? != 0 ] ; then # Sacar el codigo del ultimo comando
  echo "ZxY--!!!WKW no encontrado"
fi
echo "ya es suficiente... Para mas informacion teclee 'man bash'." 
</verb></tscreen>

<sect1>Sus programas en C
<p>

Bajo Unix, el lenguaje del sistema es C, le guste o no. Pero otros
lenguajes como FORTRAN, Pascal, Lisp, Basic, Perl, awk... también están
disponibles. 

Suponiendo que usted sepa C, hay un par de guías para aquellos que han
utilizado Turbo C++ o uno de sus hermanos bajo DOS. El compilador de C se
denomina gcc y carece de todas las florituras que normalmente acompañan a
sus análogos bajo DOS: no tiene IDE, ni ayuda en línea, ni debugger
integrado, etc... Es sólo un rústico compilador de línea de comandos, muy
potente y eficiente. Para compilar el típico programa <tt/hello.c/ esto es
lo que debe teclear: 

<tscreen><verb>
$ gcc hello.c
</verb></tscreen>

lo que creará un fichero ejecutable llamado <tt/a.out/. Para cambiar el
nombre del ejecutable a otro nombre: 

<tscreen><verb>
$ gcc -o hola hello.c
</verb></tscreen>

Para enlazar una librería al programa, añada la opción
<tt/-lnombre_de_librería/. Por ejemplo, para enlazar la librería
<tt/math/:

<tscreen><verb>
$ gcc -o mathprog mathprog.c -lm
</verb></tscreen>

(<tt/-lnombre_libreria/ fuerza a gcc a enlazar la librería
<tt>/usr/lib/libnombre_librería.a</tt>; por lo tanto <tt/-lm/ enlaza
<tt>/usr/lib/libm.a</tt>). 

Bien. Pero cuando su programa está compuesto por varios ficheros de código
fuente, necesitará usar la utilidad <tt/make/. Supongamos que ha escrito
un evaluador de expresiones: su código fuente se denomina <tt/parser.c/ e
tiene un <tt/#include/ de dos ficheros en su cabecera: <tt/parser.h/ y
<tt/xy.h/. Entonces, desea utilizar las rutinas de <tt/parser.c/ en otro
programa, <tt/calc.c/, que hace un <tt/#include/ de <tt/parser.h/. ¡Vaya
lío! ¿Cómo se puede compilar <tt/calc.c/? 

Debe escribir un fichero llamado <tt/makefile/, el cual muestra al
compilador las dependencias entre los ficheros de código fuente y los
ficheros de código objeto. En nuestro ejemplo: 

<tscreen><verb>
# Este es el makefile, utilizado para compilar calc.c
# ¡Pulse la tecla <TAB> en las posiciones marcadas!

calc: calc.o parser.o
<TAB>gcc -o calc calc.o parser.o -lm
# calc depende de dos ficheros de codigo objeto: calc.o and parser.o

calc.o: calc.c parser.h
<TAB>gcc -c calc.c
# calc.o depende de dos ficheros de codigo fuente

parser.o:  parser.c parser.h xy.h
<TAB>gcc -c parser.c
# parser.o depende de tres ficheros de codigo fuente

# fin de makefile.
</verb></tscreen>

Guarde esto como <tt/makefile/ y teclee

<tscreen><verb>
$ make
</verb></tscreen>

para compilar su programa; alternativamente, guárdelo como <tt/calc.mak/ y
teclee

<tscreen><verb>
$ make -f calc.mak
</verb></tscreen>

Y, por supuesto, LPM.

Puede pedir ayuda acerca de las funciones de C, que se encuentra en las
páginas <tt/man/, sección 3; por ejemplo: 

<tscreen><verb>
$ man 3 printf
</verb></tscreen>

Hay muchas librerías disponibles por ahí; entre las primeras que deseará
usar están las <tt/ncurses/, para manejar efectos en modo de texto, y
<tt/svgalib/, para hacer gráficos. Si se siente suficientemente valiente
para atacar la programación de las X, consiga XForms (<tt><htmlurl
url="ftp://bloch.phys.uwm.edu/pub/xforms" 
name="bloch.phys.uwm.edu/pub/xforms"></tt>) y/o MGUI (<tt><htmlurl
url="http://www.volftp.vol.it/IT/IT/ITALIANI/MORELLO/index.htm" 
name="http://www.volftp.vol.it/IT/IT/ITALIANI/MORELLO/index.htm"></tt>),
dos fantásticas librerías que hacen de la programación bajo X algo
realmente fácil. Más aún, si no puede vivir sin un IDE al estilo Borland,
consiga el paquete <tt/xwpe/ de <tt><htmlurl
url="ftp://sunsite.unc.edu/pub/Linux/apps/editors/" 
name="ftp://sunsite.unc.edu/pub/Linux/apps/editors/"></tt>. Posiblemente
sea de su agrado.

<sect>El restante 1&percnt;
<p>

<sect1>Gestión de Memoria Virtual
<p>

Aunque Linux puede ejecutarse en teoría con sólo 2 megas de RAM, cuanto
más se tenga, más se puede hacer. El sistema X Window no se ejecutará a
menos que tenga 8 megas. Para crear una memoria virtual de 8 megas
adicionales, teclee como root: 

<tscreen><verb>
# dd if=/dev/zero of=/swapfile bs=1024 count=8192
# mkswap /swapfile 8192
# sync
# swapon /swapfile
</verb></tscreen>

Añada la última línea en <tt>/etc/rc.d/rc.local</tt> para hacer que el
fichero de memoria virtual esté disponible la siguiente vez que arranque,
o añada esta línea en <tt>/etc/fstab</tt>: 

<tscreen><verb>
/swapfile   swap   swap   defaults
</verb></tscreen>

<sect1>Utilización de <tt>tar</tt> y <tt>gzip</tt>
<p>

Bajo Unix hay algunas aplicaciones ampliamente utilizadas para archivar y
comprimir ficheros. <tt/tar/ se utiliza para archivar varios ficheros en
uno ---es como PKZIP o ARJ, pero no comprime, sólo archiva. Para archivar
varios ficheros en uno (que llamaremos archivo de ahora en adelante):

<tscreen><verb>
$ tar -cvf <nombre_fichero_final.tar> <fichero1> [fichero2...]
</verb></tscreen>

Para extraer ficheros de un archivo:

<tscreen><verb>
$ tar -xpvf <nombre_fichero.tar> [fichero]
</verb></tscreen>

Para listar los ficheros contenidos de un archivo:

<tscreen><verb>
$ tar -tf <nombre_fichero.tar> | less
</verb></tscreen>

Puede comprimir los ficheros usando <tt/compress/, el cual es obsoleto y no
debería ser utilizado nunca más, o usando <tt/gzip/: 

<tscreen><verb>
$ compress <fichero>
$ gzip <fichero>
</verb></tscreen>

eso crea un fichero comprimido con la extensión <tt/.Z/ (compress) o
<tt/.gz/ (gzip). Estos programas sólo pueden comprimir un fichero cada
vez. Para descomprimir, use:

<tscreen><verb>
$ compress -d <fichero.Z>
$ gzip -d <fichero.gz>
</verb></tscreen>

LPM.

Las utilidades <tt/unarj/, <tt/zip/ y <tt/unzip/ (compatibles con ARJ y
PK??ZIP) también están disponibles. Los ficheros con la extensión
<tt/.tar.gz/ o <tt/tgz/ (archivados con <tt/tar/, posteriormente
comprimidos con <tt/gzip/) son tan comunes en el mundo Unix como los
ficheros <tt/.ZIP/ bajo DOS. Para listar los contenidos de un fichero
<tt/.tar.gz/ utilice:

<tscreen><verb>
$ gzip -dc <fichero.tar.gz> | tar tf - | less
</verb></tscreen>

o también:

<tscreen><verb>
$ tar -cvzf <fichero.tar.gz>
</verb></tscreen>

<sect1>Instalación de aplicaciones
<p>

Antes de nada: instalar paquetes es trabajo del root. Algunas aplicaciones
Linux se distribuyen como ficheros <tt/.tar.gz/ o <tt/.tgz/, preparadas
específicamente para que sean descomprimidas desde el directorio raíz
<tt>/</tt> escribiendo el siguiente comando: 

<tscreen><verb>
# gzip -dc <fichero.tar.gz> | tar xvf -
</verb></tscreen>

Los ficheros se descomprimirán en el directorio adecuado, el cual será
creado ``al vuelo''. Los usuarios de la distribución Slackware tienen un
programa gestor de paquetes amigable para el usuario; otro programa es
<tt/rpm/, el cual está disponible para todas las distribuciones gracias a
Red Hat. 

Los demás paquetes no deberían ser instalados desde <tt>/</tt>; 
típicamente, el paquete contendrá un directorio llamado
<tt>nombrepaquete/</tt> y un montón de ficheros y/o subdirectorios dentro
de <tt>nombrepaquete/</tt>. Una buena regla es instalar todos esos
paquetes bajo <tt>/usr/local</tt>. 

Además, otros paquetes se distribuyen con sus fuentes en C o C++, los
cuales han de ser compilados para crear los programas binarios. En la
mayor parte de los casos, todo lo que debe hacer es ejecutar <tt/make/.
Obviamente, necesitará el compilador <tt/gcc/. 

<sect1>Trucos imprescindibles
<p>

<itemize> <item><bf/Terminación de comandos/: presionando <tt/TAB/
mientras teclea un comando completará la línea por usted. Ejemplo: tiene
que teclear <tt/gcc este_es_un_nombre_de_fichero_largo.c/; con teclear
<tt/gcc este TAB/ bastará. (Si tiene otros ficheros que comienzan con los
mismos caracteres, proporcione los caracteres suficientes para resolver
cualquier ambigüedad.) 

<item><bf/Visión de pantallas anteriores/: presionar <tt/MAYÚS + RE PÁG/
(la tecla gris) le permite volver atrás unas cuantas páginas, dependiendo
de la memoria de vídeo que posea. 

<item><bf/Resetear la pantalla/: si por un casual hace un <tt/cat/ o un
<tt/more/ de un fichero binario, su pantalla puede acabar llena de basura.
Para arreglar las cosas, teclee <tt/reset/ a ciegas o pulse esta secuencia
de caracteres: <tt/echo CTRL-V ESC c RETURN/.

<item><bf/Pegar texto/: en consola, ver más abajo; en las X, haga click y
arrastre para seleccionar el texto en una ventana xterm, después haga
click en el botón central (o con los dos a la vez si tiene un ratón de dos
botones) para pegar. También hay un <tt/xclipboard/ (portapapeles de X) 
(de momento, sólo para texto); no se confunda por su muy baja velocidad de
respuesta. 

<item><bf/Usar el ratón/: instale <tt/gpm/, el controlador de ratón para
la consola. Haga click y arrastre para seleccionar texto, entonces haga un
click con el botón derecho para pegar el texto seleccionado. Funciona a
través de diferentes consolas virtuales. 

<item><bf/Mensajes del kernel/: échele un vistazo a
<tt>/var/adm/messages</tt> o <tt>/var/log/messages</tt> como root para ver
lo que el kernel le dice, incluyendo los mensajes de inicio. 
</itemize>

<sect1>Programas y comandos útiles
<p>

Esta lista refleja mis preferencias y necesidades personales, por
supuesto. En primer lugar, dónde encontrarlas. Ya que usted sabe cómo
navegar por la red y cómo utilizar <tt/archie/ y <tt/ftp/, sólo le daré
tres de las más importantes direcciones para Linux: <tt><htmlurl
url="ftp://sunsite.unc.edu/" name="ftp://sunsite.unc.edu/"></tt>,
<tt><htmlurl url="ftp://tsx-11.mit.edu/"
name="ftp://tsx-11.mit.edu/"></tt>, y <tt><htmlurl
url="ftp://nic.funet.fi/" name="ftp://nic.funet.fi/"></tt>. Por favor, use
el mirror más cercano. 

<itemize>

<item><tt/at/ le permite ejecutar programas a una hora y fecha
especificados. 

<item> <tt/awk/ es un lenguaje simple pero potente de manipulación de
ficheros de datos (entre otras cosas). Por ejemplo, siendo <tt/datos.dat/
su fichero de datos multicampo,

<tscreen><verb>
$ awk '$2 ~ "abc" {print $1, "\t", $4}' datos.dat
</verb></tscreen>

imprime los campos 1 y 4 de cada linea de <tt/datos.dat/ cuyo segundo
campo contenga ``<tt/abc/''.

<item><tt/delete-undelete/ borran y recuperan ficheros; 

<item><tt/df/ da información acerca de los discos montados;

<item><tt/dosemu/ permite ejecutar bastantes (no todos) programas DOS
---incluyendo Windows 3.x--- con un poco de trasteo;

<item><tt/file nombrefichero/ le dice qué tipo de fichero es
<tt/nombrefichero/ (texto ASCII, ejecutable, comprimido, etc.);

<item><tt/find/ (ver también la sección <ref id="Directorios">) es uno de
los comandos más potentes y útiles. Se utiliza para buscar ficheros que se
ajusten a unas determinadas características, y realizar acciones sobre
ellos. El uso general de <tt/find/ es:

<tscreen><verb>
$ find <directorio> <expresion>
</verb></tscreen>

donde <tt/expresion/ incluye criterios de búsqueda y acciones. Ejemplos:

<tscreen><verb>
$ find . -type l -exec ls -l {} \;
</verb></tscreen>

busca todos los ficheros que son enlaces simbólicos y dice a dónde
apuntan. 

<tscreen><verb>
$ find / -name "*.old" -ok rm {} \;
</verb></tscreen>

busca todos los ficheros que se ajusten a lo especificado y los borra,
pidiéndole antes confirmación. 

<tscreen><verb>
$ find . -perm +111
</verb></tscreen>

busca todos los ficheros cuyos permisos sean <tt/111/ (ejecutables para
todos).

<tscreen><verb>
$ find . -user root
</verb></tscreen>

busca todos los ficheros que pertenecen al root. Hay muchas
posibilidades: LPM. 

<item><tt/gnuplot/ es un brillante programa para dibujos científicos; 

<item><tt/grep/ busca cadenas de texto en ficheros. Por ejemplo: 

<tscreen><verb>
$ grep -l "geologia" *.tex
</verb></tscreen>

lista todos los ficheros <tt/*.tex/ que contienen la palabra
<tt/geologia/. La variante <tt/zgrep/ trabaja en ficheros comprimidos con
gzip. LPM;

<item><tt/gzexe/ comprime binarios ejecutables manteniéndolos ejecutables
(similar a PKLITE); 

<item><tt/joe/ es un excelente editor. Invocándolo tecleando <tt/jstar/
conseguirá los mismos caracteres de teclado que WordStar y sus
descendientes, incluyendo DOS y los editores Turbo... de Borland; 

<item><tt/less/ es, probablemente, el mejor navegador de texto, y si está
adecuadamente configurado, permite navegar por ficheros <tt/zip/, <tt/tar/
o <tt/gzip/. 

<item><tt/lpr fichero/ imprime un fichero en segundo plano. Para comprobar
el estado de la cola de impresión, use <tt/lpq/; para quitar un fichero de
la cola de impresión, use <tt/lprm/; 

<item><tt/mc/ es un maravilloso gestor de ficheros, clon del
<it/comandante norton/;

<item><tt/pine/ es un simpático programa gestor de correo electrónico; 

<item><tt/script fichero_script/ copia a <tt/fichero_script/ lo que
aparece en pantalla antes de ejecutar el comando exit. Util para
depuración;

<item><tt/sudo/ permite a los usuarios ejecutar algunas funciones del root
(p.e. formatear y montar discos; LPM); 

<item><tt/uname -a/ da información acerca del sistema;

<item><tt/zcat/ y <tt/zless/ son útiles para ver ficheros de texto
comprimidos con <tt/gzip/ sin descomprimirlos. Un posible uso es: 

<tscreen><verb>
$ zless ficherotexto.gz
$ zcat ficherotexto.gz | lpr
</verb></tscreen>

<item> Los siguientes comandos son a menudo utilizados: <tt/bc, cal, chsh,
cmp, cut, fmt, head, hexdump, nl, passwd, printf, sort, split, strings,
tac, tail, tee, touch, uniq, w, wall, wc, whereis, write, xargs, znew/.
LPM. 
</itemize>

<sect1>Extensiones comunes y programas relacionados
<p>

Se podrá encontrar con una gran variedad de extensiones de ficheros. 
Excluyendo los más exóticos (como los de fuentes, etc.), aquí tenemos una
lista de los más usuales: 

<itemize>

<item><tt>1 ... 8</tt>: páginas de manual. En el extraño caso en que aún
no lo tenga, consiga <tt/man/. 

<item><tt>arj</tt>: archivo hecho con <tt/arj/. Use <tt/unarj/ para
descomprimirlo. 

<item><tt>dvi</tt>: fichero de salida producido por TeX (ver más abajo).
Use <tt/xdvi/ para visualizarlo; Use <tt/dvips/ para transformarlo en un
fichero PostScript (<tt/.ps/). 

<item><tt>gif</tt>: fichero gráfico. Consiga <tt/seejpeg/, <tt/xpaint/ o
<tt/zgv/ para visualizarlo. 

<item><tt>gz</tt>: archivo comprimido con <tt/gzip/. 

<item><tt>info</tt>: archivo <em/info/ (Algo así como una alternativa a
las páginas de manual). Consiga <tt/info/. 

<item><tt>jpg, jpeg</tt>: fichero gráfico. Consiga <tt/seejpeg/ o
<tt/zgv/. 

<item><tt>lsm</tt>: Fichero <em/Linux Software Map/. Es un fichero de
texto ASCII plano que contiene la descripción de un paquete. 

<item><tt>ps</tt>: Fichero PostScript. Para visualizarlo o imprimirlo
consiga <tt/gs/ y, opcionalmente, <tt/ghostview/. 

<item><tt>rpm</tt>: Paquete de Red Hat. Puede instalarlo en cualquier
sistema utilizando el gestor de paquetes <tt/rpm/. 

<item><tt>taz, tar.Z</tt>: archivo hecho con <tt/tar/ y posteriormente
comprimido con <tt/compress/. 

<item><tt>tgz, tar.gz</tt>: archivo hecho con <tt/tar/ y posteriormente
comprimido con <tt/gzip/. 

<item><tt>tex</tt>: fichero de texto para utilizar con TeX, un poderoso
formateador de textos. Consiga el paquete <tt/tex/, disponible en muchas
distribuciones; pero tenga cuidado con NTeX, el cual tenía fuentes
corruptas y estaba incluido en algunas versiones de la distribución
Slackware. 

<item><tt>texi</tt>: fichero texinfo, a partir del cual se pueden producir
tanto archivos TeX como info. Consiga <tt/texinfo/. 

<item><tt>xbm, xpm, xwd</tt>: fichero gráfico. Consiga <tt/xpaint/.

<item> <tt/Z/: archivo hecho con <tt/compress/.

<item> <tt/zip/: archivo hecho con <tt/zip/. Consiga <tt/zip/ y <tt/unzip/.
</itemize>

<sect>Fin, por ahora
<p>

¡Felicidades! Se ha iniciado un poco en el Unix y está preparado para
comenzar a trabajar. Recuerde que su conocimiento del sistema es aún
limitado, y que se espera que practique más con Linux para usarlo
cómodamente. Pero si todo lo que quería hacer era conseguir un puñado de
aplicaciones y empezar a trabajar con ellas, apuesto a que lo que se
incluyó aquí fue suficiente. 

Estoy seguro de que habrá disfrutado de usar Linux y seguirá aprendiendo
más acerca de él ---todo el mundo lo hace---. Apuesto, también, que nunca
volverá al DOS. Espero haberme hecho entender y haber realizado un buen
servicio a mis 3 o 4 lectores. 

<sect1>Copyright
<p>

A menos que se establezca lo contrario, los documentos COMO de Linux
tienen copyright de sus respectivos autores. Los documentos COMO de Linux
pueden ser reproducidos y distribuidos de manera completa o en parte, en
cualquier medio físico o electrónico, siempre y cuando este aviso de
copyright se mantenga en todas las copias. Se permite y se anima a la
redistribución comercial; sin embargo, al autor le gustaría ser notificado
de cualquier distribución. 

Todas las traducciones, trabajos derivados o agregados que incorporen
cualquier documento COMO de Linux debe ser mantenido bajo este aviso de
Copyright. Esto es, no puede producir un trabajo derivado de un documento
COMO e imponer restricciones adicionales a su distribución. Excepciones a
estas reglas pueden ser concedidas bajo ciertas condiciones;  por favor,
contacte con el coordinador de los COMO de Linux en la dirección dada más
abajo. 

En resumen, deseamos promocionar la dispersión de esta información a través
de cuantos canales sea posible. Sin embargo, deseamos retener el copyright
de los documentos COMO, y nos gustaría tener noticias de cualquier plan de
redistribuir los COMOs. 

Si tiene dudas, contacte con Greg Hankins, el coordinador de Linux HOWTO,
en <tt><htmlurl url="mailto:gregh@sunsite.unc.edu" 
name="gregh@sunsite.unc.edu"></tt> vía e-mail.

<sect>Agradecimientos
<p>

"DOS-to-Linux-HOWTO" fue escrito por Guido Gonzato, <tt><htmlurl
url="mailto:guido@ibogfs.df.unibo.it"
name="guido@ibogfs.df.unibo.it"></tt>. Muchas gracias a Matt Welsh, el
autor de "<it/Linux: Instalación y Primeros Pasos/", a Ian Jackson, el
autor de "<it/Linux frequently asked questions with answers/", a Giuseppe
Zanetti, el autor de "Linux", a todos los amigos que me enviaron
sugerencias, y especialmente a Linus Torvalds y GNU que nos trajeron
Linux. 

Este documento se distribuye "tal cual". He puesto un gran esfuerzo en
escribirlo tan correctamente como he podido. Pese a ello, la información
contenida en el mismo debe ser utilizada bajo su propia responsabilidad. 
En ningún caso el autor será responsable de cualquier daño resultante del
uso de este documento. 

El correo es bienvenido. Para cualquier duda, sugerencia, crítica, etc.,
siéntase libre de contactar conmigo. 

Disfrute de Linux y de la vida,

Guido   <tt/=8-)/					


<sect1>Traducción
<p>

"<it/CÓMO pasar de DOS a LINUX/" fue traducido por David Martín Carreño,
<tt><htmlurl url="mailto:davefx@bigfoot.com" 
name="davefx@bigfoot.com"></tt>, como un pequeño grano de arena más dentro
del Proyecto INSFLUG. Para más información, vea la sección <ref
id="Grupos">.

He intentado una traducción fidedigna del documento original de Guido,
aunque en algunos lugares haya actualizado información o cambiado algunas
expresiones por otras más adecuadas a la jerga en nuestro idioma. 

Si desea plantear alguna duda, sugerencia o crítica, pues tampoco dude en
contactar conmigo. 

David!! 3B-)

<sect>Anexo: El INSFLUG <label id="Grupos">
<p>

El <em/INSFLUG/ forma parte del grupo internacional 
<it/Linux Documentation Project/, 
encargándose de las traducciones al castellano de los Howtos (Comos),
así como la producción de documentos originales en aquellos casos
en los que no existe análogo en inglés.

En el <bf/INSFLUG/ se orienta preferentemente a la traducción de documentos
breves, como los <em/COMOs/ y <em/PUFs/ (<bf/P/reguntas de
<bf/U/so <bf/F/recuente, las <it/FAQs/. <tt/:)/ ), etc.

Diríjase a la sede del INSFLUG para más información al respecto.

En la sede del INSFLUG encontrará siempre las <bf/últimas/ versiones 
de las traducciones:  <tt><htmlurl url="http://www.insflug.org" 
name="www.insflug.org"></tt>. Asegúrese de comprobar cuál es la última versión 
disponible en el Insflug antes de bajar un documento de un servidor réplica.

Se proporciona también una lista de los servidores
réplica (<it/mirror/) del Insflug más cercanos a Vd.,  
e información relativa a otros recursos en castellano.

Francisco José Montilla, <tt><htmlurl url="mailto:pacopepe@insflug.org"
name="pacopepe@insflug.org"></tt>.
</article>
