<!doctype linuxdoc system>

<article>

<title> From DOS/Windows to Linux HOWTO 

<author> di Guido Gonzato <tt>&lt;guido@ibogfs.cineca.it&gt;</tt>

<date> Versione 1.2.4. 29 Dicembre 1997.

<abstract>

Questo HOWTO e' dedicato a tutti gli utenti DOS che hanno deciso di passare a
Linux, il clone Unix per PC 386 e superiori. Date le analogie tra DOS e
Unix, lo scopo di questo lavoro e' di aiutare il lettore a trasportare le sue
conoscenze di DOS nell'ambiente Linux, cosi' da poter lavorare da subito.

</abstract>

<toc>

<sect> Introduzione

<p>

<sect1> Linux fa per voi?

<p>

Volete passare dal DOS a Linux? Benissimo, ma attenzione: potrebbe non
esservi utile. Credo che ``il computer migliore'' o ``il migliore sistema
operativo'' non esistano: dipende dall'uso che se ne fa. Ecco perché non
credo che Linux sia la soluzione migliore per tutti, nonostante sia
tecnicamente superiore a molti sistemi operativi commerciali. Avrete grandi
benefici da Linux se vi serve sw per la programmazione, Internet, TeX... sw
tecnico in generale, ma se vi serve soprattutto sw commerciale, o se non vi
piace l'idea di studiare i comandi, e' meglio lasciare perdere.

Linux non e' (per ora) facile da usare o da configurare come Windows o il
Mac, quindi siate preparati a smanettare un po'. Nonstante questi
avvertimenti, sono sicuro al 100&percnt; che se appartienete alla giusta
categoria di utenti troverete in Linux il vostro Nirvana informatico. E
comunque Linux e DOS/Windows possono convivere sulla stessa macchina.

Prerequisiti per questo howto: daro' per scontato che

<itemize>

<item> conoscete i principali comandi e concetti del DOS;

<item> Linux, e magari anche X Window System, e' correttamente installato;

<item> la vostra shell---l'equivalente di <tt/COMMAND.COM/---e' <tt/bash/;

<item> capite che questo lavoro e' solo un inizio. Per maggiori informazioni,
guardatevi ``Linux Installation and Getting Started'' di Matt Welsh e/o 
``Linux User Guide'' di Larry Greenfield
(<tt><htmlurl url="ftp://sunsite.unc.edu:/pub/Linux/docs/LDP"
name="sunsite.unc.edu:/pub/Linux/docs/LDP"></tt>).

</itemize>

Questo howto sostituisce il vecchio mini--howto di uguale titolo.

<sect1> Si', fa per me. Spiegami

<p>

Avete installato Linux e i programmi che vi servono. Vi siete fatti un
account (se non l'avete fatto, scrivete <tt/adduser/ <em/subito!/) e Linux
sta girando. Avete inserito nome e password e ora state guardando lo
schermo e pensate: ``Beh, e adesso?''

Adesso, non disperate. Siete quasi pronti per fare le stesse cose che
facevate col DOS, e molte altre in piu'. Se steste lavorando col DOS anziché
con Linux, ora fareste una di queste cose:

<itemize>

<item> eseguire programmi e creare, copiare, visualizzare, cancellare,
stampare e rinominare files;

<item> spostarsi tra directory, crearne di nuove, cancellarle, elencarne i
contenuti;

<item> formattare floppy e copiarci file su/da;

<item> sistemare <tt/AUTOEXEC.BAT/ e <tt/CONFIG.SYS/;

<item> scrivere i vostri .BAT files e/o programmi in <tt/QBasic/ o C/Pascal;

<item> il rimanente 1&percnt;.

</itemize>

Sarete contenti di sapere che queste cose si fanno con Linux in un modo
molto simile al DOS. Sotto DOS, l'utente medio usa solo pochi tra i 100 e
passa comandi disponibili; lo stesso vale per Linux, almeno fino ad un certo
punto.

Alcune cose da aver chiare prima di proseguire:

<itemize>

<item> primo, come uscire da Linux. Se si vede una schermata non grafica,
premere CTRL--ALT--DEL, aspettare che il sistema dica che tutto e' a posto,
poi spegnere pure. Se si sta lavorando sotto X Window System, prima premere
CTRL--ALT--BACKSPACE, poi CTRL--ALT--DEL. Non spegnere <em/mai/ il PC
direttamente: si potrebbe danneggiare il filesystem;

<item> a differenza del DOS, Linux ha meccanismi di sicurezza, a causa della
sua natura multiutente. I file e le directory hanno dei permessi, e
quindi ad alcuni l'utente normale non puo' accedere (vedi la sezione <ref
id="Permessi" name="Permessi">). Solo l'utente il cui nome di login e'
``root'' puo' fare cio' che vuole (root e' l'amministratore di sistema. Se
usate Linux sul vostro PC, sarete anche root). Il DOS, al contrario, vi
lascia cancellare tutto l'hard disk per sbaglio;

<item> siete incoraggiati a sperimentare, giocare, provare: di certo male non
fa. Potete ottenere aiuto in questo modo:

  <itemize>

  <item> per ottenere aiuto sui ``comandi interni'' della shell, scrivete
  <tt>help</tt>;
  
  <item> per ottenere aiuto su un comando, scrivete <tt>man command</tt> che
  richiama la pagina di manuale (man page) del comando in questione. In
  alternativa, scrivete <tt>info command</tt> che richiama, se c'e', la
  pagina info relativa al comando. Info e' un sistema di documentazione ad
  ipertesti, non molto intuitivo da usare le prime volte. Potete provare
  inoltre a dare i comandi <tt>whatis command</tt> o <tt>apropos
  command</tt> e premere `q' per uscire.

  </itemize>

<item> buona parte della potenza e flessibilita' di Unix derivano dai semplici
concetti di redirezione e piping, piu' potenti che non sotto DOS. Semplici
comandi possono essere combinati per eseguire operazioni complesse. Usate
questa caratteristica!

<item> convenzioni: <tt/<...>/ indica qualcosa che deve essere specificato,
mentre <tt/[...]/ indica qualcosa di opzionale. Esempio:

<tscreen><verb>
$ tar -tf <file.tar> [> redir_file]
</verb></tscreen>

<tt/file.tar/ deve essere specificato, mentre la redirezione su
<tt/redir_file/ e' opzionale.

<item> d'ora in avanti ``LMP'' significa ``leggere la man page per ulteriori
informazioni''.

</itemize>

<sect1> Per l'impaziente

<p>

Volete partire subito? Date un'occhiata a questa tabella:

<tscreen><verb>

DOS              	Linux			Note
------------------------------------------------------------------------------

BACKUP 			tar -Mcvf device dir/	totalmente diversi
CD dirname\		cd dirname/		quasi la stessa sintassi
COPY file1 file2	cp file1 file2          idem
DEL file             	rm file              	attenzione - niente undelete
DELTREE	dirname		rm -R dirname/		idem
DIR             	ls              	non proprio la stessa sintassi
DIR file/s		find . -name file	totalmente diverso
EDIT file            	vi file              	credo che non vi piacera'
                        emacs file              questo e' migliore
                        jstar file              quasi come l'editor del DOS
FORMAT          	fdformat,
			mount, umount   	sintassi molto diversa
HELP command            man command             stessa filosofia
MD dirname		mkdir dirname/		quasi la stessa sintassi
MOVE file1 file2	mv file1 file2		idem
NUL             	/dev/null       	idem
PRINT file          	lpr file             	idem
PRN             	/dev/lp0,
			/dev/lp1        	idem
RD dirname		rmdir dirname/		quasi la stessa sintassi
REN file1 file2		mv file1 file2          non per file multipli
RESTORE			tar -Mxpvf device	sintassi diversa
TYPE file            	less file           	molto migliore
WIN			startx			un mondo a parte!
</verb></tscreen>

Se vi serve di piu' che una tabella di comandi, leggetevi le prossime sezioni.


<sect> File e programmi

<p>

<sect1> File: nozioni preliminari

<p>

Linux ha un file system---intendendo con cio' ``la struttura delle directory
e dei file in esse contenuti''---molto simile a quello del DOS. I file hanno
dei nomi che seguono certe regole, sono messi in directory, alcuni sono
eseguibili, e tra questi ultimi molti hanno degli switch. Inoltre, ci sono i
caratteri wildcards, la redirezione e il piping. Ci sono solo alcune piccole
differenze:

<itemize>

<item> sotto DOS, i nomi dei file seguono la regola dell'8.3; per esempio,
ILMIOFIL.TXT. Sotto Linux si puo' fare meglio. Se avete installato Linux con
un filesystem come ext2 o umsdos, potete usare nomi piu' lunghi, e con piu' di
un punto: per esempio, <tt/Ecco.un_NOME_molto.LUNGO/. Notare che ho usato
lettere maiuscole e minuscole: infatti...

<item> maiuscole e minuscole sono considerate diverse. Quindi, 
<tt/FILENAME.tar.gz/ e <tt/filename.tar.gz/ sono due file diversi. 
<tt/ls/ e' un comando, <tt/LS/ e' un errore;

<item> gli utenti di Windows 95 possono usare i nomi di file lunghi con
Linux, naturalmente. Se il nome di un file contiene spazi (pratica
sconsigliata ma possibile), bisogna racchiudere il nome del file tra apici
quando vi ci si riferisce. Per esempio:

<tscreen><verb>
$ # questo comando crea una directory di nome "I miei file vecchi"
$ mkdir "I miei file vecchi"
$ ls
I miei file vecchi	bin	tmp
</verb></tscreen>

Alcuni caratteri non dovrebbero ma possono essere usati; tra gli altri,
<tt>!*&dollar;&amp</tt>. Non vi spiego come.

<item> non ci sono estensioni obbligatorie come .COM ed .EXE per i
programmi, o .BAT per i file batch. I files eseguibili sono contrassegnati
da un asterisco <tt/'*'/ alla fine del loro nome quando si da' il comando 
<tt/ls -F/. Per esempio: 

<tscreen><verb>
$ ls -F
Direttorio/   cindy.jpg    cjpg*    lettera.txt    script*    vecchio~
</verb></tscreen>

I files  <tt/cjpg*/ e <tt/script*/ sono eseguibili---``programmi''. 
Sotto DOS, i file di backup hanno il nome che finisce in .BAK, sotto Linux
finiscono con una tilde '<tt/&tilde;/'. Inoltre, un file il cui nome inizia
con un punto viene considerato un file nascosto. Per esempio, il file
<tt/.io.sono.nascosto/ non apparira' dopo il comando <tt/ls/.

<item> gli switch dei programmi DOS si ottengono con <tt>/switch</tt>, con i
programmi Linux si ottengono con <tt/-switch/ or <tt/--switch/. Esempio:
<tt>dir /s</tt>  diventa <tt/ls -R/. Notare che molti programmi DOS, come
PKZIP o ARJ, hanno gli switch in stile Unix.

</itemize>

Ora potete saltare alla sezione <ref id="Files" name="Tradurre i comandi
dal DOS a Linux">, ma se fossi in voi continuerei a leggere.

<sect1> Link simbolici

<p>

Unix ha un tipo di file che il DOS non ha: il link simbolico. Questo e' un
puntatore ad un file o directory, e puo' essere usato al posto del file o
directory a cui punta; e' molto simile ai colegamenti di Windows 95. Esempi
di link simbolici sono <tt>/usr/X11</tt>, che punta a <tt>/usr/X11R6</tt>;
<tt>/dev/modem</tt>, che punta a <tt>/dev/cua0</tt> o <tt>/dev/cua1</tt>.

Per fare un link simbolico:

<tscreen><verb>
$ ln -s <file_o_dir> <nomelink>
</verb></tscreen>

Esempio:

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

Ora potete riferirvi a <tt/g77manual.txt/ al posto di 
<tt>/usr/doc/g77/DOC</tt>. Ecco come appaiono i link quando date <tt>ls</tt>:

<tscreen><verb>
$ ls -F
g77manual.txt@
$ ls -l
(various things...)           g77manual.txt -> /usr/doc/g77/DOC
</verb></tscreen>
 

<sect1> Permessi e Proprieta' <label id="Permessi">

<p>

I file e le directory DOS hanno i seguenti attributi: A (archivio), H
(hidden, nascosto), R (read-only, solo lettura), and S (system, file di
sistema). Solo H e R hanno senso sotto Linux: i files nascosti iniziano con
un punto, e per quanto riguarda l'attributo R, continuate a leggere.

Sotto Unix un file ha dei ``permessi'' e un proprietario, che appartiene ad
un ``gruppo''. Guardate questo esempio:

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

Il primo campo contiene i permessi del file <tt>/bin/ls</tt>, 
che appartiene a root, gruppo bin. Tralasciando le altre informazioni (il
libro di Matt Welsh e' li' per quello), ricordate che <tt/-rwxr-xr-x/ 
significa (da sinistra a destra):

<tt/-/ e' il tipo di file (- = file normale, d = directory, l = link, 
etc.); <tt/rwx/ sono i permessi per il proprietario del file (read, write, 
execute); <tt/r-x/ sono i permessi per il gruppo cui il proprietario del
file appartiene (non spieghero' il concetto di gruppo, ne potete fare a meno
finché siete principianti ;-) <tt/r-x/ sono i permessi per tutti gli altri
utenti (read, execute).

Anche la directory <tt>/bin</tt> ha dei permessi: vedi la sezione <ref
id="Permessi delle directory" name="Permessi delle directory"> per ulteriori
dettagli. Ecco perché non potete cancellare il file <tt>/bin/ls</tt>, a
meno che non siate root: non avete i permessi necessari. Per cambiare i
permessi di un file, il comando e':

<tscreen><verb>
$ chmod <whoXperm> <file>
</verb></tscreen>

dove who e' <tt/u/ (user, cioe' proprietario), <tt/g/ (group, gruppo), <tt/o/
(other, altri), X e' <tt/+/ o <tt/-/, perm e' <tt/r/ (read, lettura), <tt/w/
(write, scrittura), o <tt/x/ (execute, esecuzione). Esempi:

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

setta il permesso di esecuzione per il proprietario. Scorciatoia: 
<tt/chmod +x file/.

<tscreen><verb>
$ chmod go-rw file
</verb></tscreen>

toglie i permessi di lettura e scrittura per tutti tranne il proprietario.

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

da' a tutti i permessi di lettura, scrittura ed esecuzione.

<tscreen><verb>
# chmod +s file
</verb></tscreen>

rende un file ``setuid'' o ``suid'': ciascuno lo puo' eseguire con i
permessi del proprietario. Di solito si incontrano file ``suid root''.

Una maniera piu' breve di riferirsi ai permessi e' con i numeri:
<tt/rwxr-xr-x/ puo' essere espresso con 755 (ogni lettera corrisponde a un
bit: <tt/---/ e' 0, <tt/--x/ e' 1, <tt/-w-/ e' 2, <tt/-wx/ e' 3...). Sembra
difficile, ma con un po' di pratica capirete il concetto.

root, essendo il cossiddetto superutente, puo' cambiare i permessi di ogni
file. C'e' molto di piu' sull'argomento---LMP.

<sect1> Convertire i comandi dal DOS a Linux <label id="Files">

<p>

Alla sinistra, i comandi DOS; a destra, i corrispondenti comandi Linux.

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

Operatori per la redirezione e il plumbing: <tt/ < > >> |/

Wildcards: <tt/* ?/

<tt>nul:	/dev/null</tt>

<tt>prn, lpt1:	/dev/lp0 or /dev/lp1; lpr</tt>

- ESEMPI -

<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
C:\GUIDO>TYPE LETTER.TXT > NUL    	$ cat letter.txt > /dev/null
	n/a                             $ more *.txt *.asc
	n/a                             $ cat section*.txt | less
</verb></tscreen>

Note:

<itemize>

<item> * e' migliore sotto Linux: * prende tutti i file tranne quelli
nascosti; .* tutti i file nascosti (ma anche la directory corrente `<tt/./' 
e la directory genitrice `<tt/../'); *.* prende tutti i file che hanno un
`.' nel mezzo o che finiscono per punto; p*a prende sia `pera' che
`palla'; *l* prende sia `mela' che `filo';

<item> usando <tt/more/, premere SPAZIO per leggere il file, 
`q' o CTRL-C per uscire. <tt/less/ e' piu' intuitivo, si possono usare i tasti
freccia;

<item> non c'e' <tt/UNDELETE/, quindi <em/pensarci bene/ prima di cancellare
un file;

<item> oltre a <tt/&lt; &gt; &gt;&gt;/ del DOS, Linux ha <tt/2&gt;/ per
redirigere i messaggi di errore (stderr); inoltre, <tt/2&gt;&amp;1/ redirige
stderr su stdout, mentre <tt/1&gt;&amp;2/ redirige stdout su stderr;

<item> Linux ha un altro wildcard: la coppia <tt/[]/. Uso: <tt/[abc]*/
prende i file che cominciano con a, b, c; <tt/*[I-N,1,2,3]/ prende i file
che finiscono con I, J, K, L, M, N, 1, 2, 3;

<item> non c'e' un <tt/RENAME/ alla DOS; cioe', <tt/mv/ *.xxx *.yyy 
non funziona. Potete usare questo script; dettagli alla sezione
<ref id="Shell Scripts" name="Shell Scripts">.

<code>
#!/bin/sh
# ren: rename multiple files according to several rules

if [ $# -lt 3 ] ; then
  echo "usage: ren \"pattern\" \"replacement\" files..."
  exit 1
fi
    
OLD=$1 ; NEW=$2 ; shift ; shift
    
for file in $*
do
  new=echo ${file} | sed s/${OLD}/${NEW}/g  mv ${file} $new
done
</code>

Attenti pero': non e' equivalente al <tt>REN</tt> del DOS, poiché usa le
``regular expressions'' che non conoscete ancora. In breve, se volete
cambiare le estensioni dei file, scrivete: <tt/ren ``htm&dollar;'' ``html''
*htm/. Non dimenticate il <tt/&dollar;/.

<item> usare <tt/cp -i/ e <tt/mv -i/ per essere avvisati se un file sta per
essere sovrascritto.

</itemize>

<sect1> Programmi: Multitasking e Sessioni

<p>

Per far partire un programma, si scrive il suo nome come col DOS. Se la
directory (Sezione <ref id="Directories" name="Directories">) dove il
programma risiede e' nel PATH (Sezione <ref id="Files di inizializzazione"
name="Files di inizializzazione">), il programma parte. Eccezione: sotto
Linux, un programma che sta nella directory corrente non parte se la
directory non e' inclusa nel PATH. Scappatoia: se <tt/prog/ e' il programma,
scrivere <tt>./prog</tt>.

Questa e' una tipica linea di comando:

<tscreen><verb>
$ command -s1 -s2 ... -sn par1 par2 ... parn < input > output
</verb></tscreen>

dove <tt>-s1</tt>, ..., <tt>-sn</tt> sono gli switch del programma,
<tt/par1/, ..., <tt/parn/ sono gli argomenti del programma. Si possono dare
piu' comandi sulla stessa linea:

<tscreen><verb>
$ command1 ; command2 ; ... ; commandn
</verb></tscreen>

Tutto qui per quanto riguarda i programmi, ma e' facile fare dei passi
avanti. Uno dei vantaggi di Linux e' il multitasking: puo' far girare piu'
programmi (d'ora in poi, processi) allo stesso tempo. Si possono lanciare
programmi in background e continuare a lavorare. Inoltre, Linux mette a
disposizione piu' sessioni di lavoro contemporanee: e' come avere tanti
computer allo stesso tempo!

<itemize>

<item> Per passare di sessione in sessione (1..6) nelle console virtuali:

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

<item> Per far partire un'altra sessione nella stessa console virtuale 
senza lasciare quella corrente:

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

Esempio:

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

Questo e' utile, tra l'altro, per usare i floppy (Sezione <ref id="Floppies" 
name="Floppies">): normalmente, solo root lo puo' fare.

<item> Per chiudere una sessione:

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

Se ci sono dei job sospesi (vedi piu' avanti) si viene avvisati.

<item> Per lanciare normalmente un processo in primo piano:

<tscreen><verb>
$ progname [-switches] [parameters] [< input] [> output]
</verb></tscreen>

<item> Per lanciare un processo in background, aggiungere una `e commerciale'
'<tt/&amp;/' alla fine della linea di comando:

<tscreen><verb> 
$ progname [-switches] [parameters] [< input] [> output] &
[1] 123
</verb></tscreen> 

la shell identifica i processi dando loro un numero (es. <tt/[1]/; vedi
sotto) e un PID (123 nel nostro esempio).

<item> Per vedere quanti processi ci sono:

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

Questo comando da' una lista dei processi attualmente in esecuzione.

<item> Per uccidere (terminare) un processo:

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

Potreste dover uccidere un processo se non sapete come uscirne normalmente...
;-). A volte, un processo si puo' uccidere solo con:

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

Oltre a questo, la shell consente di fermare o sospendere un processo,
mandare un processo in background, e portare un processo dal background in
primo piano. In questo contesto, i processi sono chiamati `job'.

<item> Per vedere quanti job ci sono:

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

qui i job sono identificati dal loro numero, non dal PID.

<item> Per fermare un job che gira in primo piano (non sempre funziona):

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

<item> Per sospendere un processo che gira in primo piano (idem):

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

<item> Per mandare in background un processo sospeso:

<tscreen><verb>
$ bg <job>
</verb></tscreen>

<item> Per portare un job in primo piano:

<tscreen><verb>
$ fg <job>
</verb></tscreen>

<item> Per uccidere un job:

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

dove &lt;job&gt; puo' essere 1, 2, 3, ...  Usando questi comandi si puo'
formattare un disco, zippare dei files, compilare un programma e
decompattare un archivio tutto allo stesso tempo, e ancora avere il prompt a
disposizione. Provate a farlo col DOS! E provate con Windows, giusto per
vedere la differenza in performance.

</itemize>

<sect1> Eseguire programmi su computer remoti

<p>

Per eseguire un programma su un computer remoto il cui indirizzo IP e'
<tt/remote.bigone.edu/, si fa:

<tscreen><verb>
$ telnet remote.bigone.edu
</verb></tscreen>

Dopo il login, si fa partire il programma. Ovviamente, bisogna avere uno
shell account sul computer remoto.

Se avete X11, si possono far girare anche applicazioni X sul computer
remoto, e queste verranno visualizzate sul vostro schermo. Siano
<tt/remote.bigone.edu/ il computer remoto e <tt/local.linux.box/ il vostro
PC. Per far girare da <tt/local.linux.box/ un programma X che sta su
<tt/remote.bigone.edu/, si fa:

<itemize>

<item> far partire X11 ed un <tt/xterm/ o equivalente emulatore di
terminale, poi digitare:

<tscreen><verb>
$ xhost +remote.bigone.edu
$ telnet remote.bigone.edu
</verb></tscreen>

<item> dopo il login, digitare:

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

(invece di <tt/DISPLAY.../, potreste dover scrivere: <tt/setenv DISPLAY 
local.linux.box:0.0/. Dipende dalla shell remota.)

</itemize>

Et voila! Ora <tt/progname/ parte su <tt/remote.bigone.edu/ e viene
visualizzato sulla vostra macchina. È pero' meglio non provarci tramite modem,
perché e' assolutamente troppo lento.


<sect> Usare le directory <label id="Directories">

<p>

<sect1> Directory: nozioni preliminari

<p>

Abbiamo visto le differenze tra i file sotto DOS e sotto Linux. Per quanto
riguarda le directory, sotto DOS la directory principale e' \, sotto Linux
e' /. In maniera analoga, le directory sono separate da \ sotto DOS e da /
sotto Linux. Esempio:

<tscreen><verb>
DOS:    C:\PAPERS\GEOLOGY\MID_EOC.TEX
Linux:  /home/guido/papers/geology/mid_eocene.tex
</verb></tscreen>

Come al solito, <tt/../ e' la directory genitrice, <tt/./ e' la directory
corrente. Ricordate che il sistema non vi lascia fare <tt/cd/, <tt/rd/ o
<tt/md/ ovunque si vuole. Ogni utente ``risiede'' in una sua directory
chiamata 'home', che viene assegnata dall'amministratore di sistema. Per
esempio, sul mio PC la mia home directory e' <tt>/home/guido</tt>.

<sect1> Permessi delle directory <label id="Permessi delle directory">

<p>

Anche le directory hanno i permessi. Quanto visto in Sezione <ref
id="Permessi" name="Permessi"> vale anche per le directory (user,
group, e other). Per una directory, <tt/rx/ significa che potete fare
<tt/cd/ nella directory, e <tt/w/ significa che potete cancellare i file
nella directory, o la directory stessa. Per esempio, per impedire ad altri
utenti di curiosare in <tt>/home/guido/text</tt>:

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

<sect1> Tradurre i comandi dal DOS a Linux

<p>

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

- ESEMPI -

<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 - vedi nota                 $ cd
	idem                            $ cd ~
	idem                            $ cd ~/temp
C:\GUIDO>CD \OTHER                   	$ cd /other
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>

Note: 

<enum>

<item> quando usate <tt/rmdir/, la directory da cancellare deve essere
vuota. Per cancellare una directory e tutto il suo contenuto, usate 
<tt/rm -R/ (a vostro rischio e pericolo).

<item> il carattere '<tt/&tilde;/' e' una scorciatoia per il nome della home
directory. I commandi <tt/cd/ o <tt/cd ~/ portano nella home directory
ovunque voi siate; il comando <tt>cd ~/tmp</tt> vi porta in
<tt>/home/la_vostra_home/tmp</tt>.

<item> <tt/cd -/ ``annulla'' l'ultimo <tt/cd/.

</enum>

<sect> Floppy, hard disk, e cosi' via <label id="Floppies">

<p>

<sect1> Gestire i dispositivi

<p>

Forse non ci avete mai pensato, ma il comando DOS <tt/FORMAT A:/ fa molte
piu' cose di quanto sembri. Infatti, quando date il comando <tt/FORMAT/ 
quello 1) formatta fisicamente il disco; 2) crea la directory A:\ 
(crea un filesystem); 3) rende il disco accessibile all'utente (= fa il
cosiddetto ``mount'').

Questi tre passaggi si fanno separatamente con Linux. Si possono usare
floppy formattati da DOS, ma ci sono altri formati che di solito e' meglio
usare (il filesystem DOS non consente di usare i nomi lunghi per i file.)

Ecco come si prepara un floppy (bisogna essere root):

<itemize>

<item> per formattare un floppy standard da 1.44: (A:):
<tscreen><verb>
# fdformat /dev/fd0H1440
</verb></tscreen>

<item> per creare un filesystem:
<tscreen><verb>
# mkfs -t msdos -c /dev/fd0H1440
</verb></tscreen>

Per creare un filesystem MS-DOS, usate <tt>msdos</tt> invece di <tt>ext2</tt>.
Prima di usare il disco, bisogna ``montarlo''. 

<item> per montare il floppy:
<tscreen><verb>
# mount -t ext2 /dev/fd0 /mnt
</verb></tscreen>
oppure
<tscreen><verb>
# mount -t msdos /dev/fd0 /mnt
</verb></tscreen>

Ora si puo' accedere ai file del floppy. Quando si ha finito, prima di
estrarre il floppy <em/bisogna/ ``smontarlo''.

<item> per smontare il floppy:
<tscreen><verb>
# umount /mnt
</verb></tscreen>

</itemize>

Ora potete estrarre il disco. Ovviamente, eseguire <tt/fdformat/ e <tt/mkfs/
solo per floppy nuovi, non per quelli gia' preparati. Se volete usare il
floppy B:, basta sostituire <tt/fd1H1440/ e <tt/fd1/ al posto di
<tt/fd0H1440/ e <tt/fd0/ negli esempi visti sopra.

Tutto quello che facevate con A: o B: si fa ora usando <tt>/mnt</tt>.
Esempi:

<tscreen><verb>

DOS                                     Linux
---------------------------------------------------------------------

C:\GUIDO>DIR A:                      	$ ls /mnt
C:\GUIDO>COPY A:*.* 			$ cp /mnt/* .
C:\GUIDO>COPY *.ZIP A:               	$ cp *.zip /mnt
C:\GUIDO>A:                          	$ cd /mnt
A:>_					/mnt/$ _
</verb></tscreen>

Se non vi piace questa faccenda di montare/smontare i dischi, usate la suite
<tt>mtools</tt>: si tratta di un insieme di comandi equivalenti a quelli del
DOS, ma che iniziano con la `m': <tt>mformat</tt>, <tt>mdir</tt>,
<tt>mdel</tt> e cosi' via. Funzionano anche con i nomi lunghi, ma si perdono
i permessi dei file. Usate questi comandi come usereste quelli DOS, e siete
a posto.

Inutile dire che quanto visto per i floppy vale anche per altri dispositivi;
per esempio, si possono montare un altro disco fisso o un lettore di CD-ROM.
Ecco come si monta il CD-ROM:

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

Questa era la maniera ``ufficiale'' di montare i dischi, ma c'e' un
trucchetto. Dover essere root per usare un floppy e' una scocciatura, quindi
per consentire ad ogni utente di accedervi si puo' fare cosi':

<itemize>

<item> come root, date questi comandi:

<tscreen><verb>
~# mkdir /mnt/a: ; mkdir /mnt/a ; mkdir /mnt/cdrom
~# chmod 777 /mnt/a* /mnt/cd*
~# # assicuratevi che il device del CD-ROM e' quello giusto
~# chmod 666 /dev/hdb ; chmod 666 /dev/fd*
</verb></tscreen>

<item> aggiungere in <tt>/etc/fstab</tt> le linee seguenti:
<tscreen><verb>
/dev/cdrom      /mnt/cdrom  iso9660 ro,user,noauto          0       0
/dev/fd0        /mnt/a:     msdos   user,noauto             0       0
/dev/fd0        /mnt/a      ext2    user,noauto             0       0
</verb></tscreen>

</itemize>

Ora per montare un floppy DOS, uno in formato ext2 e un CD-ROM si fa
semplicemente:

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

<tt>/mnt/a</tt>, <tt>/mnt/a:</tt> e <tt>/mnt/cdrom</tt> sono accessibili da
tutti. Ricordate che consentire a tutti di montare dischi in questo modo e'
un grosso problema di sicurezza, se la cosa vi puo' interessare.


<sect1> Fare il backup <label id="Backing Up">

<p>

Ora che sapete come gestire i dispositivi, due righe per vedere come si fa
il backup. Ci sono molti programmi per questo scopo, ma il minimo necessario
che si puo' fare per un backup multivolume su floppy e' quanto segue
(diventate root):

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

Assicuratevi di avere un floppy formattato nel drive, e altri pronti a
disposizione. Per fare il restore, inserite il primo floppy nel drive e
immettete:

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


<sect> E Windows?

<p>

L'``equivalente'' di Windows e' l'ambiente grafico X11. A differenza di
Windows o del Mac, X11 non e' stato progettato per la facilita' d'uso o per
risultare attraente, ma per fornire capacita' grafiche alle workstation UNIX.
Ecco le differenze principali:

<itemize>

<item> Windows ha sempre lo stesso look and feel, X11 no: e' di gran lunga
piu' configurabile. L'aspetto generale di X11 e' dato da un componente
importantissimo chiamato ``window manager''; ce ne sono molti tra cui
scegliere. I piu' comuni sono <tt>fvwm</tt>, semplice ma gradevole ed
efficiente in termini di memoria, <tt>fvwm2-95</tt> e <tt>The Next
Level</tt> che danno a X11 un aspetto simile a Windows 95, piu' molti altri.
Alcuni sono davvero bellissimi;

<item> il window manager puo' essere configurato in modo tale che una
finestra si comporta come quelle di Windows: cliccate su di essa per
portarla in primo piano. In alternativa, si puo' fare in modo che una
finestra sia in primo piano quando il puntatore del mouse e' sopra di essa.
Questa caratteristica (``focus'') e molte altre si modificano adattando uno
o piu' file di configurazione. Leggete la documentazione del vostro window
manager;

<item> i programmi di X11 sono scritti usando speciali librerie (``widget
set''); ce ne sono svariate, e quindi i programmi possono avere un aspetto
diverso. I piu' elementari usano i widget Athena (aspetto 2--D;
<tt>xdvi</tt>, <tt>xman</tt>, <tt>xcalc</tt>), altri usano Motif
(<tt>netscape</tt>), altri ancora usano Tcl/Tk, XForms, Qt ed altri ancora.
Alcuni di questi widget set danno ai programmi un aspetto simile a quello
dei programmi Windows;

<item> questo riguardava il ``look'' dei programmi, ma il ``feel''?
Purtroppo, tutti i programmi si comportano in modo diverso. Per esempio, se
selezionate una linea di testo e premete BACKSPACE vi aspettereste che la
linea scomparisse, vero? Questo non funziona con i programmi Athena, ma
funziona con quelli Motif, Qt e Tcl/Tk;

<item> barre di scorrimento, ridimensionamento, iconizzazione: anche queste
cose dipendono dal window manager e dal widget set. Ci sarebbero troppe cose
da dire, quindi ve ne indichero' solo una, poco intuitiva. Quando usate le
applicazioni Athena, le barre di scorrimento si spostano usando il tasto
centrale del mouse, oppure i tasti destro e sinistro insieme;

<item> i programmi non hanno un'icona per default, ma ne possono avere
tante. Dipende dal window manager. Il desktop e' chiamato ``root window'' e
se ne modifica l'aspetto con programmi come <tt>xsetroot</tt> o
<tt>xloadimage</tt>;

<item> la clipboard puo' contenere solo testo e si comporta in modo strano.
Quando del testo viene selezionato, e' anche automaticamente copiato nella
clipboard: spostatevi in un altro punto e premete il tasto centrale per
copiarlo nella nuova locazione. C'e' un programma, <tt>xclipboard</tt>, che
fornisce buffer multipli per la clipboard;

<item> drag and drop e' un'opzione ed e' supportato solo da alcuni programmi.

</itemize>

Per risparmiare memoria, e' meglio usare applicazioni che usano gli stessi
widget set, ma e' difficile da fare in pratica. C'e' un progetto chiamato K
Desktop Environment che vuole rendere X11 coerente nel look and feel come lo
e' Windows; attualmente e' solo in beta ma, credetemi, e' meraviglioso. Rendera'
l'interfaccia di Windows una cosa di cui vergognarsi. Puntate il vostro
browser su <tt><htmlurl url="http://www.kde.org" 
name="http://www.kde.org"></tt>.


<sect> Configurare il sistema

<p>

<sect1> File di inizializzazione <label id="Files di inizializzazione">

<p>

Due file importanti sotto DOS sono <tt/AUTOEXEC.BAT/ e <tt/CONFIG.SYS/, e
vengono usati al momento del boot per inizializzare il sistema, settare le
variabili d'ambiente come PATH e FILES, e magari lanciare un programma o
batch file. Sotto Linux ci sono tanti file di inizializzazione, e con
molti di questi e' meglio non pasticciare finché non si sa esattamente cosa
si sta facendo. Vi diro' comunque quali sono i piu' importanti:

<tscreen><verb>

FILES                           	NOTES

/etc/inittab                    	non toccare!
/etc/rc.d/*                     	idem

</verb></tscreen>

Se tutto quello che vi serve e' settare il PATH o qualche altra variabile, o
se volete cambiare i messaggi di login o lanciare un programma subito dopo
il login, date un'occhiata ai seguenti:

<tscreen><verb>

FILES                           	NOTES

/etc/issue                      	setta i messaggi pre-login
/etc/motd                       	setta i messaggi post-login
/etc/profile                    	setta PATH e altre variabili, etc.
/etc/bashrc                     	setta alias e funzioni globali
/home/your_home/.bashrc   		setta i vostri alias e funzioni
/home/your_home/.bash_profile  oppure 	
/home/your_home/.profile		setta il vostro environment, etc.

</verb></tscreen>

Se l'ultimo file esiste (notare che e' un file nascosto), verra' letto dopo il
login e i suoi comandi vengono eseguiti.

Esempio: date un occhio a questo <tt/.profile/:

<code>
# Io sono un commento
echo Environment:
printenv | less   # equivalente del comando SET sotto DOS
alias d='ls -l'   # facile capire cos'e' un alias
alias up='cd ..'
echo "Ti ricordo che il path e' " $PATH
echo "Oggi e' `date`"  # usa l'output del comando 'date'
echo "Buongiorno " $LOGNAME
# Questa e' una "funzione della shell":
ctgz() # Lista i contenuti di un archivio .tar.gz.
{
  for file in $*
  do
    gzip -dc ${file} | tar tf -
  done
}         
# fine di .profile
</code>

<tt/&dollar;PATH/ e <tt/&dollar;LOGNAME/, avete indovinato, sono variabili
d'ambiente. Ce ne sono molte altre con cui giochicchiare; LMP di programmi
come <tt/less/ o <tt/bash/.


<sect1> File di inizializzazione dei programmi

<p>

Sotto Linux, praticamente tutto puo' essere personalizzato. Molti programmi
hanno uno o piu' file di inizializzazione che potete modificare, spesso
sotto forma di  <tt/.nome_del_programmarc/ nella vostra home. I primi che
vorrete modificare sono:

<itemize>

<item> <tt/ .inputrc/: usato da <tt/bash/ per definire i tasti.

<item> <tt/ .xinitrc/: usato da <tt/startx/ per initializzare X Window System.

<item> <tt/ .fvwmrc/: usato dal window manager <tt/fvwm/. Un esempio e' in:
<tt>/usr/lib/X11/fvwm/system.fvwmrc</tt>

<item> <tt/ .Xdefault/: usato da <tt/rxvt/, un emulatore di terminale per X,
e altri programmi.

</itemize>

Per tutti questi e gli altri che prima o poi incontrerete, LMP.


<sect> Un po' di programmazione

<p>

<sect1> Shell script: super file .BAT  <label id="Shell Scripts">

<p>

Se usavate i file .BAT per creare diminutivi di lunghe linee di comando (io
lo facevo spesso), questo si puo' ottenere inserendo degli alias in
<tt/profile/ o <tt/.profile/. Ma se i vostri .BAT erano piu' complessi, vi
piacera' il linguaggio di scripting della shell: e' potente come il QBasic, se
non di piu'. Ha variabili, strutture come while,
for, case, if... then... else, e molte altre caratteristiche: puo' essere una
buona alternativa ad un ``vero'' linguaggio di programmazione.

Per scrivere un file script---l'equivalente di un .BAT file sotto DOS---non
si fa altro che scrivere un file ASCII contenente le istruzioni, lo si salva
e poi lo si rende eseguibile col comando <tt/chgmod +x &lt;scriptfile>/. Per
eseguirlo si scrive il suo nome.

Attenzione pero'. L'editor di sistema si chiama <tt/vi/, e ho visto che molti
nuovi utenti lo trovano molto difficile da usare. Non spieghero' come usarlo
perché non mi piace e non lo uso; consultate ``Linux installation...'' di
Matt Welsh, a pag. 109. (Fareste meglio a procurarvi un altro editor come
<tt/joe/ o <tt/emacs/ per X.) Basti dire che:

<itemize>
<item> per inserire del testo, premete 'i' e poi il testo;
<item> per uscire da <tt/vi/ senza salvare, premete ESC e poi :q!
<item> per salvare e uscire, premete ESC e poi :wq
</itemize>

Scrivere script sotto <tt/bash/ e' un argomento cosi' vasto che richiederebbe
un libro per conto suo, e non daro' spiegazioni ma solo un esempio piuttosto
completo di shell script, dal quale potrete intuire le regole di base:

<code>

#!/bin/sh
# esempio.sh
# Io sono un commento
# non cambiate la prima linea, deve restare cosi' com'e'
echo "Questa macchina e': `uname -a`" # usa l'output del comando
echo "Il mio nome e' $0" # variabile interna
echo "Mi hai dato i seguenti $# argomenti: " $*
echo "Il primo argomento e': " $1
echo -n "Come ti chiami? " ; read nome
echo guarda la differenza: "ciao $nome" # meccanismo di quoting con "
echo guarda la differenza: 'ciao $nome' # meccanismo di quoting con '
DIRS=0 ; FILES=0
for file in `ls .` ; do
  if [ -d ${file} ] ; then # se file e' una directory
    DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1
  elif [ -f ${file} ] ; then
    FILES=`expr $FILES + 1`
  fi
  case ${file} in
    *.gif|*jpg) echo "${file}: file grafico" ;;
    *.txt|*.tex) echo "${file}: file di testo" ;;
    *.c|*.f|*.for) echo "${file}: file sorgente" ;;
    *) echo "${file}: file generico" ;;
  esac
done
echo "ci sono ${DIRS} directories e ${FILES} files"
ls | grep "ZxY--!!!WKW"
if [ $? != 0 ] ; then # exit code dell'ultimo comando
  echo "non ho trovato ZxY--!!!WKW"
fi
echo "basta cosi'... scrivi 'man bash' se vuoi altre informazioni."

</code>


<sect1> Programmare in C

<p>

Sotto Unix, il linguaggio di programmazione per eccellenza e' il C, vi
piaccia o no. Ci sono anche molti altri linguaggi a disposizione (FORTRAN,
Pascal, Lisp, Basic, Perl, awk...).

Dato per scontato che conosciate il C, ecco qui un paio di linee guida per
quelli di voi che sono stati viziati dal Turbo C++ o analogo compilatore. Il
compilatore C di Linux si chiama <tt/gcc/ e non ha tutte quelle cose che di
solito accompagnano un compilatore per DOS: niente IDE, aiuto in linea,
debugger integrato e cosi' via. È solo un compilatore a linea di comando,
molto potente ed efficiente. Per compilare il classico <tt/hello.c/ si fa
cosi':

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

che produce di default un eseguibile chiamato <tt/a.out/. Per dargli un nome
diverso:

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

Per linkare una libreria al programma, si aggiunge lo switch
-l&lt;libname&gt;. Per esempio, per linkare la libreria matematica:

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

(Lo switch <tt>-l&lt;libname&gt;</tt> fa linkare a <tt/gcc/ la libreria
<tt>/usr/lib/lib&lt;libname&gt;.a</tt>; quindi <tt/-lm/ linka
<tt>/usr/lib/libm.a</tt>).

Finora, tutto bene. Ma se il vostro programma e' composto da molti file
sorgenti, vi servira' l'utility <tt/make/. Supponiamo che avete scritto un
parser per espressioni: il sorgente si chiama <tt/parser.c/ e &num;include
due file header, <tt/parser.h/ e <tt/xy.h/. Volete usare le routine di
<tt/parser.c/ in un programma, diciamo <tt/calc.c/, che a sua volta
&num;include <tt/parser.h/. Che casino! Cosa bisogna fare per compilare
<tt/calc.c/?

Dovrete scrivere un cosiddetto <tt/makefile/, che insegna al compilatore
quali sono le dipendenze tra sorgenti e files oggetto. Nel nostro caso:

<code>

# Questo e' makefile, usato per compilare calc.c
# Premere il tasto <TAB> dove indicato

calc: calc.o parser.o
<TAB>gcc -o calc calc.o parser.o -lm
# calc dipende da due files oggetto: calc.o e parser.o

calc.o: calc.c parser.h
<TAB>gcc -c calc.c
# calc.o dipende da due files sorgenti

parser.o:  parser.c parser.h xy.h
<TAB>gcc -c parser.c
# parser.o dipende da tre files sorgenti

# end of makefile.
</code>

Salvate questo file come <tt/makefile/ e scrivete <tt>make</tt>
per compilare il programma; in alternativa, salvatelo come <tt/calc.mak/ e 
scrivete <tt>make -f calc.mak</tt>. Ovviamente, LMP. Potete ottenere aiuto
sulle funzioni del C, che sono illustrate da pagine man, sezione 3; per
esempio,

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

Ci sono tantissime librerie disponibili; tra le prime che vorrete usare ci
sono <tt/ncurses/, per gestire effetti in modo testo, e <tt/svgalib/, per
fare grafica. Se vi sentite abbastanza coraggiosi da affrontare la
programmazione sotto X, procuratevi 
<tt/XForms/ (<tt> <htmlurl url="ftp://bloch.phys.uwm.edu/pub/xforms"
name="bloch.phys.uwm.edu/pub/xforms"></tt>) e/o una delle tante librerie che
rendono facile la programmazione sotto X. Date un'occhiata a <tt>
<htmlurl url="http://www.xnet.com/~blatura/linapp6.html"
name="http://www.xnet.com/~blatura/linapp6.html"> </tt>. 

Molti editor possono fungere da IDE; <tt>emacs</tt> e <tt>jed</tt>, ad
esempio, hanno l'evidenziazione della sintassi, l'indent automatico e altre
cose. Oppure, prendete il programma <tt/rhide/ da <tt><htmlurl
url="ftp://sunsite.unc.edu:/pub/Linux/devel/debuggers/"
name="sunsite.unc.edu:/pub/Linux/devel/debuggers/"></tt>. E' un clone della
IDE Borland, e probabilmente vi piacera'.


<sect> Il rimanente 1&percnt;

<p>

<sect1> Usare <tt/tar/ &amp; <tt/gzip/

<p>

Sotto Unix ci sono alcune applicazioni usatissime per archiviare e
comprimere i file. <tt/tar/ e' usato per fare archivi---e' come <tt/PKZIP/ ma
non comprime, archivia soltanto. Per fare un nuovo archivio:

<tscreen><verb>
$ tar -cvf <archive_name.tar> <file> [file...]
</verb></tscreen>

Per estrarre files da un arhivio:

<tscreen><verb>
$ tar -xpvf <archive_name.tar> [file...]
</verb></tscreen>

Per listare il contenuto di un archivio:

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

I file si comprimono con <tt/compress/, che e' obsoleto e non dovrebbe
essere piu' usato, o con <tt/gzip/:

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

che crea un file file compresso con estensione .Z (<tt/compress/) o .gz 
(<tt/gzip/). Questi programmi comprimono solo un file alla volta. Per
decomprimere, scrivete

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

LMP.

Ci sono anche <tt/unarj/, <tt/zip/ e <tt/unzip/ (PK??ZIP compatibile). I
files con estensione <tt/.tar.gz/ o <tt/.tgz/ (archivi fatti con <tt/tar/ e
compressi con <tt/gzip/) sono comuni nel mondo Unix come i files .ZIP sotto
DOS. Per listare i contenuti di un file <tt/.tar.gz/:

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

<sect1> Installare le applicazioni <label id="Install">

<p>

Prima di tutto: installare nuove applicazioni e' compito di root. Alcune
applicazioni Linux sono distribuite come archivi <tt/.tar.gz/ o <tt/.tgz/,
fatti in modo da poter essere scompattati dalla directory / col seguente
comando:

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

oppure, in modo equivalente, 

<tscreen><verb>
$ tar -zxf <file.tar.gz>
</verb></tscreen>

I file vengono decompressi nella directory giusta, che viene creata sul
momento. Gli utenti della distribuzione Slackware hanno il programmino
<tt/pkgtool/; un altro e' <tt/rpm/, disponibile per tutte le distribuzioni
grazie a Red Hat.

Altri package non possono essere installati da /; tipicamente, l'archivio
contiene una directory chiamata <tt>nome_programma/</tt> e tanti files e/o
sottodirectories sotto <tt>nome_programma/</tt>. Una regola e' quella di
installare questi programmi da <tt>/usr/local</tt>. Inoltre, altri programmi
sono distribuiti come sorgenti in C o C++ che vanno compilati per fare gli
eseguibili. In molti casi, basta dare <tt/make/; ovviamente vi servira' il
compilatore <tt/gcc/.

<sect1> Trucchi indispensabili

<p>

<bf/Command completion/: premere &lt;TAB&gt; mentre si scrive un comando al
prompt completa la linea di comando. Esempio: dovete scrivere 
<tt>gcc nome_file_molto_lungo.c</tt>; scrivendo <tt>gcc nome&lt;TAB&gt;</tt> 
e' sufficiente. (Se avete altri file che cominciano con gli stessi
caratteri, scrivete altre lettere per risolvere l'ambiguita').

<bf/Backscrolling/: premendo SHIFT + PAG UP (tasto grigio) consente di fare
lo scroll all'indietro dello schermo, a seconda di quanta memoria video
avete;

<bf/Resettare lo schermo/: puo' capitare di fare <tt/more/ o <tt/cat/ di un
file binario, e come conseguenza lo schermo potrebbe riempirsi di schifezze.
Per rimettere a posto, battere alla cieca <tt/reset/ o questa sequenza di
caratteri: <tt/echo CTRL-V ESC c RETURN/;

<bf/Incollare il testo/: per la console, vedete sotto; in X, fate click e
trascinate per selezionare il testo in una finestra <tt/xterm/, poi
premete il tasto di mezzo (o i due bottoni insieme se non avete tre tasti)
per incollare il testo selezionato altrove. C'e' anche il programma
<tt/xclipboard/ (purtroppo solo per il testo); non fatevi confondere dal suo
lentissimo tempo di risposta;

<bf/Usare il mouse/: installate <tt/gpm/, un mouse driver per la console. 
Fate click e trascinate per selezionare il testo, poi fate click col tasto
destro per incollare il testo selezionato. Funziona anche tra diverse VC.

<bf/Messaggi dal kernel/: date un occhio a <tt>/var/adm/messages</tt> 
o <tt>/var/log/messages</tt> come root per vedere i messaggi del kernel,
compresi i messaggi in fase di boot. Anche il comando <tt>dmesg</tt> e' molto
utile.


<sect1> Programmi e comandi utili

<p>

Ovviamente, questa lista riflette i miei gusti e le mie necessita' personali.
Prima di tutto, dove trovarli: sapete tutti come usare la rete, <tt/archie/
ed <tt/ftp/, quindi vi daro' solo gli indirizzi piu' importanti che riguardano
Linux:<tt> <htmlurl url="ftp://sunsite.unc.edu"
name="sunsite.unc.edu"></tt>, <tt><htmlurl url="ftp://tsx-11.mit.edu"
name="tsx-11.mit.edu"></tt>, e <tt><htmlurl url="ftp://nic.funet.fi"
name="nic.funet.fi"></tt>. Usate il vostro mirror piu' vicino.

<itemize>

<item> <tt/at/ serve per eseguire comandi e programmi ad un'ora o data
specifica;

<item> <tt/awk/ e' un linguaggio di programmazione, semplice ma potente, per
manipolare file di dati (e non solo). Per esempio, se avete un file di dati
a piu' campi chiamato <tt/data.dat/,

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

scrive i campi 1 e 4 di ogni linea in <tt/data.dat/ il cui secondo campo
contiene ``abc''.

<item> <tt/delete-undelete/ fanno quello che il loro nome suggerisce;

<item> <tt/df/ da' informazioni sui dischi montati;

<item> <tt/dosemu/ consente di far girare molte (anche se non tutte)
applicazioni DOS, incluso Windows 3.x se ci smanettate un bel po';

<item> <tt/file &lt;filename&gt;/ dice che cos'e' <tt/filename/ (file ASCII,
eseguibile, archivio, etc.);

<item> <tt/find/ (vedi anche Sezione <ref id="Directories"
name="Directories">) e' uno dei comandi piu' utili e potenti. Si usa per
trovare file che rispondono a certi criteri ed eseguire azioni su si essi.
Uso generale di <tt/find/:

<tscreen><verb>
$ find <directory> <espressione>
</verb></tscreen>

dove &lt;espressione&gt; include criteri di ricerca ed azioni da eseguire.
Esempi:

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

trova i file che sono link simbolici e mostra a cosa puntano.

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

trova i files che corrispondono al pattern e li cancella, chiedendo prima il
permesso di farlo.

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

trova i file i cui permessi corrispondono con 111 (eseguibile).

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

trova i files che appartengono a root. Ci sono molte altre possibilita', LMP.

<item> <tt/gnuplot/ e' un bel programma per il plotting scientifico;

<item> <tt/grep/ trova pattern in file di testo. Per esempio,

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

lista tutti i files *.tex che contengono la parola ``geology''. La 
variante <tt/zgrep/ agisce su file gzippati. LMP;

<item> <tt/joe/ e' un buon editor. Lanciandolo come <tt/jstar/ si ottengono
le stesse combinazioni di tasti di WordStar e dei suoi discendenti, compresi
l'editor del DOS e quello dei linguaggi Borland;

<item> <tt/less/ e' probabilmente il migliore visualizzatore di file di
testo, e se configurato consente di visualizzare archivi gzip, tar e zip;

<item> <tt/lpr/ &lt;file&gt; stampa un file in background. Per controllare
lo stato della coda di stampa, usate <tt/lpq/; per cancellare un file dalla
coda di stampa, usate <tt/lprm/;

<item> <tt/mc/ e' un bellissimo file manager;

<item> <tt/pine/ e' un buon programma per la posta elettronica;

<item> <tt/script &lt;script_file&gt;/ copia su <tt/script_file/ tutto
quello che appare sullo schermo fino a quando non date il comando <tt/exit/.
Utile per il debugging;

<item> <tt/sudo/ permette di eseguire alcuni dei compiti solitamente
concessi solo a root (es. formattare e montare dischi; LMP);

<item> <tt/tcx/ comprime files eseguibili mantenendoli eseguibili;

<item> <tt/uname -a/ da' informazioni sul sistema;

<item> <tt/zcat/ e <tt/zless/ sono utili per visualizzare file gzippati
senza decomprimerli. Per esempio:

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

<item> I seguenti comandi risultano spesso utili: <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.</tt> LMP.

</itemize>

<sect1> Estensioni di file e programmi collegati

<p>

Potrete incontrare tantissime estensioni di file. A parte le piu' esotiche
(ad es. fonts, etc.), ecco una lista:

<itemize>

<item> <tt/1 ... .8/: man page. Procuratevi <tt/man/.

<item> <tt/arj/: archivio fatto con <tt/arj/. <tt/unarj/ per estrarre i
file.

<item> <tt/dvi/: output file prodotto da TeX (vedi sotto). <tt/xdvi/ per
visualizzare; <tt/dvips/ per convertire in un file .ps (postscript)

<item> <tt/gif/: file grafico. Procuratevi <tt/seejpeg/ o <tt/xpaint/.

<item> <tt/gz/: file compresso con <tt/gzip/.

<item> <tt/info/: file info (una specie di alternativa alle man pages.).
Procuratevi <tt/info/.

<item> <tt/jpg, jpeg/: file grafico. Procuratevi <tt/seejpeg/.

<item> <tt/lsm/: Linux Software Map file. È un file ASCII 
contenente la descrizione di un package.

<item> <tt/ps/: file postscript. Per visualizzare o stampare, usare <tt/gs/
e, opzionalmente, <tt/ghostview/.

<item> <tt/tgz, tar.gz/: archivio fatto con <tt/tar/ e poi compresso con
<tt/gzip/.

<item> <tt/tex/: file di testo da comporre con TeX, un potente programma di
impaginazione. Procurarsi <tt/tex/, disponibile in molte distribuzioni;
attenti alla distribuzione NTeX, che ha dei font corrotti ed e' parte di
Slackware fino alla versione 96.

<item> <tt/texi/: file texinfo (vedi <tt/.info/). Procuratevi <tt/texinfo/.

<item> <tt/xbm, xpm, xwd/: file grafici. Procuratevi <tt/xpaint/.

<item> <tt/Z/: file compresso con <tt/compress/.

<item> <tt/zip/: archivio fatto con <tt/zip/. Procuratevi <tt/zip/ e
<tt/unzip/.

</itemize>

<sect> La fine, per ora <label id="The End">

<p>

Congratulazioni! Ora avete un po' di conoscenza di Unix e siete pronti per
iniziare a lavorare. Ricordate che la vostra conoscenza del sistema e' ancora
limitata, e che dovreste fare pratica per usare Linux senza problemi. Ma se
tutto quello che dovete fare e' prendere un po' di programmi e darci sotto,
sono sicuro che quanto ho incluso e' sufficiente.

Sono certo che usare Linux vi piacera' e continuerete ad imparare cose
nuove---lo fanno tutti. Scommetto, inoltre, che non ritornerete al DOS!
Spero di essere stato chiaro e di aver reso un buon servizio ai miei 3 o 4
lettori.

<sect1> Copyright

<p>

Unless otherwise stated, Linux HOWTO documents are copyrighted by their
respective authors. Linux HOWTO documents may be reproduced and distributed 
in whole or in part, in any medium physical or electronic, as long as
this copyright notice is retained on all copies. Commercial redistribution 
is allowed and encouraged; however, the author would like to be notified of 
any such distributions. 

All translations, derivative works, or aggregate works incorporating 
any Linux HOWTO documents must be covered under this copyright notice. 
That is, you may not produce a derivative work from a HOWTO and impose
additional restrictions on its distribution. Exceptions to these rules
may be granted under certain conditions; please contact the Linux HOWTO
coordinator at the address given below.

In short, we wish to promote dissemination of this information through as
many channels as possible. However, we do wish to retain copyright on the
HOWTO documents, and would like to be notified of any plans to redistribute
the HOWTOs. 

If you have questions, please contact Greg Hankins, the Linux HOWTO 
coordinator, at gregh@sunsite.unc.edu via email.

<sect1> Disclaimer

<p>

``Dal DOS a Linux HOWTO'' e' stato scritto da Guido Gonzato, 
<tt><htmlurl url="mailto:guido@ibogfs.cineca.it" 
name="guido@ibogfs.cineca.it"></tt>. Ringraziamenti vanno a Matt Welsh, 
autore di ``Linux Installation e Getting Started'', a Ian 
Jackson, autore di ``Linux frequently asked questions with 
answers'', a Giuseppe Zanetti, autore di ``Linux'', a tutti quelli che mi
hanno mandato mail di suggerimenti, e specialmente a Linus Torvalds 
e GNU che ci hanno dato Linux.

Questo documento viene fornito ``as is''. Mi sono sforzato di scriverlo con
la massima accuratezza, ma usate le informazioni qui contenute a vostro
rischio. Non saro' responsabile in alcun caso di danni provocati da questo
documento.

Ogni forma di feedback e' benvenuta. Per richieste, suggerimenti, flames etc.
contattatemi pure.

Divertitevi con Linux e godetevi la vita,

Guido   <tt/=8-)/

</article>
