finito paragrafo what is

Author: gfedro30

book/01-introduction/sections/what-is-git.asc

@@ -1,93 +1,226 @@
+////
 === What is Git?
+////
 
+=== Cos'é Git?
+
+////
 So, what is Git in a nutshell?
 This is an important section to absorb, because if you understand what Git is and the fundamentals of how it works, then using Git effectively will probably be much easier for you.
 As you learn Git, try to clear your mind of the things you may know about other VCSs, such as CVS, Subversion or Perforce -- doing so will help you avoid subtle confusion when using the tool.
 Even though Git's user interface is fairly similar to these other VCSs, Git stores and thinks about information in a very different way, and understanding these differences will help you avoid becoming confused while using it.(((Subversion)))(((Perforce)))
+////
+
+
+Quindi, cos'è Git in poche parole?
+Questa è una sezione importante da comprendere, perché se capisci che cos'è Git e gli elementi fondamentali di come funziona, allora sarà probabilmente molto più facile per te usare efficacemente Git.
+Mentre impari Git, cerca di liberare la tua mente dalle cose che eventualmente già conosci di altri VCS come CVS, Subversion e Perforce -- ciò ti aiuterà a evitare di far confusione utilizzando lo strumento.
+Anche se l'interfaccia utente di Git è abbastanza simile a quella degli altri VCS, Git immagazzina e tratta le informazioni in modo molto diverso, e comprendere queste differenze aiuta ad evitare di sentirsi confusi mentre lo si usa.
 
+////
 ==== Snapshots, Not Differences
+////
 
+==== Istantanee, non Differenze
+
+////
 The major difference between Git and any other VCS (Subversion and friends included) is the way Git thinks about its data.
 Conceptually, most other systems store information as a list of file-based changes.
 These other systems (CVS, Subversion, Perforce, Bazaar, and so on) think of the information they store as a set of files and the changes made to each file over time (this is commonly described as _delta-based_ version control).
+////
+
+La principale differenza tra Git e gli altri VCS (inclusi Subversion e simili), è come Git considera i suoi dati.
+Concettualmente la maggior parte degli altri sistemi salvano l'informazione come una lista di modifiche ai file.
+Questi altri sistemi (CVS, Subversion, Perforce, Bazaar e così via), considerano le informazioni che memorizzano come un insieme di file, con le relative modifiche fatte nel tempo (questo viene normalmente descritto come controllo di versione _su base delta_). 
 
+////
 .Storing data as changes to a base version of each file.
 image::images/deltas.png[Storing data as changes to a base version of each file.]
+////
 
+.Memorizzazione dei dati come cambiamenti di ogni file da una versione di base.
+image::images/deltas.png[Memorizzazione dei dati come cambiamenti di ogni file da una versione di base]
+
+////
 Git doesn't think of or store its data this way.
 Instead, Git thinks of its data more like a series of snapshots of a miniature filesystem.
 With Git, every time you commit, or save the state of your project, Git basically takes a picture of what all your files look like at that moment and stores a reference to that snapshot.
 To be efficient, if files have not changed, Git doesn't store the file again, just a link to the previous identical file it has already stored.
 Git thinks about its data more like a *stream of snapshots*.
+////
+
+Git non considera i dati né li registra in questo modo.
+Git considera i propri dati più come una sequenza di istantanee (_snapshot_) di un mini filesystem.
+Con Git, ogni volta che registri (_commit_), o salvi lo stato del tuo progetto, fondamentalmente lui fa un'immagine di tutti i file in quel momento, salvando un riferimento allo _snapshot_.
+Per essere efficiente, se alcuni file non sono cambiati, Git non li risalva, ma crea semplicemente un collegamento al file precedente già salvato.
+Git considera i propri dati più come un *flusso di istantanee*.
 
+////
 .Storing data as snapshots of the project over time.
 image::images/snapshots.png[Git stores data as snapshots of the project over time.]
+////
 
+.Memorizzazione dei dati come snapshot del progetto nel tempo.
+image::images/snapshots.png[Memorizzazione dei dati come snapshot del progetto nel tempo]
+
+////
 This is an important distinction between Git and nearly all other VCSs.
 It makes Git reconsider almost every aspect of version control that most other systems copied from the previous generation.
 This makes Git more like a mini filesystem with some incredibly powerful tools built on top of it, rather than simply a VCS.
 We'll explore some of the benefits you gain by thinking of your data this way when we cover Git branching in <<ch03-git-branching#ch03-git-branching>>.
+////
+
+Questa è una distinzione importante tra Git e pressocché tutti gli altri VCS.
+Git riconsidera quasi tutti gli aspetti del controllo di versione che la maggior parte degli altri sistemi ha copiato dalle generazioni precedenti.
+Questo rende Git più simile a un mini filesystem con a disposizione strumenti incredibilmente potenti che un semplice VCS.
+Esploreremo alcuni benefici che ottieni pensando in questo modo ai tuoi dati e vedremo le ramificazioni in Git nel <<ch03-git-branching#ch03-git-branching>>.
 
+////
 ==== Nearly Every Operation Is Local
+////
 
+==== Quasi Tutte le Operazioni Sono Locali
+
+////
 Most operations in Git need only local files and resources to operate -- generally no information is needed from another computer on your network.
 If you're used to a CVCS where most operations have that network latency overhead, this aspect of Git will make you think that the gods of speed have blessed Git with unworldly powers.
 Because you have the entire history of the project right there on your local disk, most operations seem almost instantaneous.
+////
+
+La maggior parte delle operazioni in Git, necessitano solo di file e risorse locali per operare -- generalmente non occorrono informazioni da altri computer della rete.
+Se sei abituato ad un CVCS in cui la maggior parte delle operazioni sono soggette alle latenze di rete, questo aspetto di Git ti farà pensare che gli Dei della velocità abbiano benedetto Git con poteri soprannaturali.
+Poiché hai l'intera storia del progetto sul tuo disco locale, molte operazioni sembrano quasi istantanee.
 
+////
 For example, to browse the history of the project, Git doesn't need to go out to the server to get the history and display it for you -- it simply reads it directly from your local database.
 This means you see the project history almost instantly.
 If you want to see the changes introduced between the current version of a file and the file a month ago, Git can look up the file a month ago and do a local difference calculation, instead of having to either ask a remote server to do it or pull an older version of the file from the remote server to do it locally.
+////
 
+Per esempio, per navigare la storia di un progetto, Git non ha bisogno di connettersi al server per scaricarla e per poi mostrarla -- la legge direttamente dal tuo database locale.
+Questo significa che puoi vedere la storia del progetto quasi istantaneamente.
+Se vuoi vedere le modifiche introdotte tra la versione corrente e la versione di un mese fa di un file, Git può accedere al file com'era un mese fa e calcolare le differenze localmente, invece di dover chiedere a un server remoto di farlo o di scaricare dal server remoto una versione precedente del file, per poi farlo in locale.
+
+////
 This also means that there is very little you can't do if you're offline or off VPN.
 If you get on an airplane or a train and want to do a little work, you can commit happily (to your _local_ copy, remember?) until you get to a network connection to upload.
 If you go home and can't get your VPN client working properly, you can still work.
 In many other systems, doing so is either impossible or painful.
 In Perforce, for example, you can't do much when you aren't connected to the server; in Subversion and CVS, you can edit files, but you can't commit changes to your database (because your database is offline).
 This may not seem like a huge deal, but you may be surprised what a big difference it can make.
+////
+
+Questo significa anche che sono pochissime le cose che non puoi fare se sei offline o non sei connesso alla VPN.
+Se sei in aereo o sul treno e vuoi fare un po' di lavoro, puoi eseguire _commit_ tranquillamente (alla tua copia locale, ricordi?) in attesa di essere di nuovo connesso per fare l'upload.
+Se vai a casa e il tuo client VPN non funziona correttamente, puoi lavorare ugualmente.
+In molti altri sistemi questo è impossibile o molto penoso.
+Con Perforce, per esempio, puoi fare ben poco se non sei connesso al server; e con Subversion e CVS, puoi modificare i file, ma non puoi registrare le modifiche sul tuo database (perché il database è offline).
+Tutto ciò potrebbe non sembrarti una gran cosa, ma potrebbe sorprenderti quanta differenza possa fare.
 
+////
 ==== Git Has Integrity
+////
 
+==== Git Ha Integrità
+
+////
 Everything in Git is checksummed before it is stored and is then referred to by that checksum.
 This means it's impossible to change the contents of any file or directory without Git knowing about it.
 This functionality is built into Git at the lowest levels and is integral to its philosophy.
 You can't lose information in transit or get file corruption without Git being able to detect it.
+////
+
 
+Qualsiasi cosa in Git è controllata, tramite checksum, prima di essere salvata ed è referenziata da un checksum.
+Questo significa che è impossibile cambiare il contenuto di qualsiasi file o directory senza che Git lo sappia.
+Questa è una funzionalità interna di basso livello di Git ed è intrinseca della sua filosofia.
+Non può capitare che delle informazioni in transito si perdano o che un file si corrompa senza che Git non sia in grado di accorgersene.
+
+////
 The mechanism that Git uses for this checksumming is called a SHA-1 hash.(((SHA-1)))
 This is a 40-character string composed of hexadecimal characters (0–9 and a–f) and calculated based on the contents of a file or directory structure in Git.
 A SHA-1 hash looks something like this:
+////
+
+Il meccanismo che Git usa per fare questo checksum è un hash chiamato SHA-1.(((SHA-1)))
+Si tratta di una stringa di 40-caratteri, composta da caratteri esadecimali (0–9 ed a–f) e calcolata in base al contenuto di file o della struttura della directory in Git.
+Un hash SHA-1 assomiglia a qualcosa come:
+
 
 [source]
 ----
 24b9da6552252987aa493b52f8696cd6d3b00373
 ----
 
+////
 You will see these hash values all over the place in Git because it uses them so much.
 In fact, Git stores everything in its database not by file name but by the hash value of its contents.
+////
+
+Vedrai questi hash dappertutto in Git perché li usa tantissimo.
+Infatti Git salva qualsiasi cosa nel suo database, e il riferimento ad un file non è basato sul nome del file, ma sull'hash del suo contenuto.
 
+////
 ==== Git Generally Only Adds Data
+////
+
+==== Git Generalmente Aggiunge Solo Dati
 
+////
 When you do actions in Git, nearly all of them only _add_ data to the Git database.
 It is hard to get the system to do anything that is not undoable or to make it erase data in any way.
 As with any VCS, you can lose or mess up changes you haven't committed yet, but after you commit a snapshot into Git, it is very difficult to lose, especially if you regularly push your database to another repository.
+////
 
+Quasi tutte le azioni in Git _aggiungono_ dati al database di Git.
+È difficile fare qualcosa che non sia annullabile o che cancelli i dati in una qualche maniera.
+Come con gli altri VCS, puoi perdere o fare confusione con le modifiche che non
+hai ancora registrato (commit), ma dopo aver registrato uno snapshot in Git, è veramente difficile perderle, specialmente se regolarmente fai il push del tuo database su un altro repository.
+
+////
 This makes using Git a joy because we know we can experiment without the danger of severely screwing things up.
-For a more in-depth look at how Git stores its data and how you can recover data
-that seems lost, see <<ch02-git-basics-chapter#_undoing>>.
+For a more in-depth look at how Git stores its data and how you can recover data that seems lost, see <<ch02-git-basics-chapter#_undoing>>.
+////
+
+Questo rende piacevole l'uso di Git perché sappiamo che possiamo sperimentare senza il pericolo di causare danni pesanti.
+Per un maggior approfondimento su come Git salvi i dati e come tu possa recuperare quelli che sembrino persi, consulta il <<ch02-git-basics-chapter#_undoing>>.
 
+////
 ==== The Three States
+////
 
+==== I Tre Stati
+
+////
 Pay attention now -- here is the main thing to remember about Git if you want the rest of your learning process to go smoothly.
 Git has three main states that your files can reside in: _modified_, _staged_, and _committed_:
-
 * Modified means that you have changed the file but have not committed it to your database yet.
 * Staged means that you have marked a modified file in its current version to go into your next commit snapshot.
 * Committed means that the data is safely stored in your local database.
+////
 
+Attenzione adesso -- qui c'è la cosa principale da ricordare di Git se vuoi affrontare al meglio il processo di apprendimento.
+I file in Git possono essere in tre stati principali: _modified_ (modificati), _staged_ (in stage) e _committed_ (committati).
+* Modificato significa che il file è stato modificato, ma non è ancora stato committato nel database.
+* In stage significa che hai contrassegnato un file, modificato nella versione corrente, perché venga inserito nello snapshot alla prossima commit.
+* Committato significa che il file è registrato al sicuro nel database locale.
+
+////
 This leads us to the three main sections of a Git project: the working tree, the staging area, and the Git directory.
+////
+
 
+Questo ci porta alle tre sezioni principali di un progetto Git: l'albero di lavoro, l'area di stage e la directory di Git, 
+
+////
 .Working tree, staging area, and Git directory.
 image::images/areas.png["Working tree, staging area, and Git directory."]
+////
+
+.Albero di lavoro, area di stage e directory di Git.
+image::images/areas.png["Albero di lavoro, area di stage e directory di Git."]
 
+////
 The working tree is a single checkout of one version of the project.
 These files are pulled out of the compressed database in the Git directory and placed on disk for you to use or modify.
 
@@ -96,14 +229,39 @@ Its technical name in Git parlance is the ``index'', but the phrase ``staging ar
 
 The Git directory is where Git stores the metadata and object database for your project.
 This is the most important part of Git, and it is what is copied when you _clone_ a repository from another computer.
+////
+
+L'albero di lavoro è un checkout di una versione specifica del progetto.
+Questi file vengono estratti dal database compresso nella directory di Git, e salvati sul disco per essere usati o modificati.
+
+L'area di stage è un file, contenuto generalmente nella directory di Git, con tutte le informazioni riguardanti la tua prossima commit.
+Il suo nome tecnico nel gergo di Git è 'indice', ma l'espressione 'area di stage' (area di sosta, ndt) funziona altrettanto bene.
 
+La directory di Git è dove Git salva i metadati e il database degli oggetti del tuo progetto.
+Questa è la parte più importante di Git, ed è ciò che viene copiato quando si clona un repository da un altro computer.
+
+////
 The basic Git workflow goes something like this:
 
 1. You modify files in your working tree.
 2. You selectively stage just those changes you want to be part of your next commit, which adds _only_ those changes to the staging area.
 3. You do a commit, which takes the files as they are in the staging area and stores that snapshot permanently to your Git directory.
+////
+
+Il flusso di lavoro (_workflow_) di base in Git funziona così:
 
+1. Modifica i file nel tuo albero di lavoro
+2. Seleziona per lo stage solo quei cambiamenti che vuoi facciano parte del tuo prossimo commit, che aggiunge solo queste modifiche all'area di stage.
+3. Committa, ovvero salva i file nell'area di stage in un'istantanea (_snapshot_) permanente nella tua directory di Git.
+
+////
 If a particular version of a file is in the Git directory, it's considered _committed_.
 If it has been modified and was added to the staging area, it is _staged_.
 And if it was changed since it was checked out but has not been staged, it is _modified_.
 In <<ch02-git-basics-chapter#ch02-git-basics-chapter>>, you'll learn more about these states and how you can either take advantage of them or skip the staged part entirely.
+////
+
+Se una particolare versione di un file è nella directory git, viene considerata già committata (_committed_).
+Se il file è stato modificato, ma è stato aggiunto all'area di staging, è _in stage_.
+E se è stato modificato da quando è stata estratto, ma non è _in stage_, è _modificato_.
+In <<ch02-git-basics-chapter#ch02-git-basics-chapter>>, imparerai di più su questi stati e come trarne vantaggio o saltare la parte di staging.