Merge pull request #1072 from rpjday/intro

Make some stylistic tweaks to Chapter 1, Introduction

Author: ben

book/01-introduction/sections/about-version-control.asc

@@ -30,7 +30,7 @@ RCS works by keeping patch sets (that is, the differences between files) in a sp
 (((version control,centralized)))
 The next major issue that people encounter is that they need to collaborate with developers on other systems.
 To deal with this problem, Centralized Version Control Systems (CVCSs) were developed.
-These systems, such as CVS, Subversion, and Perforce, have a single server that contains all the versioned files, and a number of clients that check out files from that central place. (((CVS)))(((Subversion)))(((Perforce)))
+These systems (such as CVS, Subversion, and Perforce) have a single server that contains all the versioned files, and a number of clients that check out files from that central place. (((CVS)))(((Subversion)))(((Perforce)))
 For many years, this has been the standard for version control.
 
 .Centralized version control.

book/01-introduction/sections/command-line.asc

@@ -3,7 +3,7 @@
 There are a lot of different ways to use Git.
 There are the original command-line tools, and there are many graphical user interfaces of varying capabilities.
 For this book, we will be using Git on the command line.
-For one, the command line is the only place you can run _all_ Git commands – most of the GUIs implement only a partial subset of Git functionality for simplicity.
+For one, the command line is the only place you can run _all_ Git commands -- most of the GUIs implement only a partial subset of Git functionality for simplicity.
 If you know how to run the command-line version, you can probably also figure out how to run the GUI version, while the opposite is not necessarily true.
 Also, while your choice of graphical client is a matter of personal taste, _all_ users will have the command-line tools installed and available.
 

book/01-introduction/sections/first-time-setup.asc

@@ -12,8 +12,10 @@ These variables can be stored in three different places:
   If you pass the option `--system` to `git config`, it reads and writes from this file specifically.
   (Because this is a system configuration file, you would need administrative or superuser privilege to make changes to it.)
 2. `~/.gitconfig` or `~/.config/git/config` file: Values specific personally to you, the user.
-  You can make Git read and write to this file specifically by passing the `--global` option.
+  You can make Git read and write to this file specifically by passing the `--global` option, and this affects _all_ of the repositories you work with on your system.
 3. `config` file in the Git directory (that is, `.git/config`) of whatever repository you're currently using: Specific to that single repository.
+  You can force Git to read from and write to this file with the `--local` option, but that is in fact the default.
+  (Unsurprisingly, you need to be located somewhere in a Git repository for this option to work properly.)
 
 Each level overrides values in the previous level, so values in `.git/config` trump those in `/etc/gitconfig`.
 

book/introduction.asc

@@ -4,12 +4,12 @@
 You’re about to spend several hours of your life reading about Git. Let’s take a minute to explain
 what we have in store for you. Here is a quick summary of the ten chapters and three appendices of this book.
 
-In *Chapter 1*, we’re going to cover Version Control Systems (VCSs) and Git basics—no
+In *Chapter 1*, we’re going to cover Version Control Systems (VCSs) and Git basics -- no
 technical stuff, just what Git is, why it came about in a land full of VCSs, what sets it apart, and
 why so many people are using it. Then, we’ll explain how to download Git and set it up for the
 first time if you don’t already have it on your system.
 
-In *Chapter 2*, we will go over basic Git usage—how to use Git in the 80% of cases you’ll
+In *Chapter 2*, we will go over basic Git usage -- how to use Git in the 80% of cases you’ll
 encounter most often. After reading this chapter, you should be able to clone a repository, see
 what has happened in the history of the project, modify files, and contribute changes. If the book
 spontaneously combusts at this point, you should already be pretty useful wielding Git in the time
@@ -41,7 +41,7 @@ enforce a custom committing policy.
 
 *Chapter 9* deals with Git and other VCSs. This includes using Git in a Subversion (SVN) world
 and converting projects from other VCSs to Git. A lot of organizations still use SVN and are
-not about to change, but by this point you’ll have learned the incredible power of Git—and this
+not about to change, but by this point you’ll have learned the incredible power of Git -- and this
 chapter shows you how to cope if you still have to use a SVN server. We also cover how to
 import projects from several different systems in case you do convince everyone to make the
 plunge.
@@ -53,16 +53,16 @@ we will refer to sections of this chapter in case you feel like diving deep at t
 but if you are like us and want to dive into the technical details, you may want to read Chapter 10 first.
 We leave that up to you.
 
-In *Appendix A* we look at a number of examples of using Git in various specific environments. We cover
+In *Appendix A*, we look at a number of examples of using Git in various specific environments. We cover
 a number of different GUIs and IDE programming environments that you may want to use Git in and what
 is available for you. If you're interested in an overview of using Git in your shell, in Visual Studio
 or Eclipse, take a look here.
 
-In *Appendix B* we explore scripting and extending Git through tools like libgit2 and JGit. If you're
-interested in writing complex and fast custom tools and need low level Git access, this is where you can
+In *Appendix B*, we explore scripting and extending Git through tools like libgit2 and JGit. If you're
+interested in writing complex and fast custom tools and need low-level Git access, this is where you can
 see what that landscape looks like.
 
-Finally in *Appendix C* we go through all the major Git commands one at a time and review where in the book
+Finally, in *Appendix C*, we go through all the major Git commands one at a time and review where in the book
 we covered them and what we did with them. If you want to know where in the book we used any specific Git
 command you can look that up here.