big boat load of fixes

Author: tony

manuscript/04-server.md

@@ -115,7 +115,7 @@ sessions, windows, and panes.
 
 Much like vi, tmux handles copying as a mode in which a pane is
 temporarily placed. When inside this mode, text can be selected and copied to
-the *paste buffer*, tmux' clipboard.
+the *paste buffer*, tmux's clipboard.
 
 The default key to enter copy mode is `Prefix` + `[`.
 

manuscript/10-scripting.md

@@ -10,7 +10,7 @@ people's flows. Full tables are in the [cheatsheets](#appendix-cheatsheets).
 ## Aliases {#aliases}
 
 tmux supports a variety of alias commands. With aliases, instead of typing
-`tmux attach-session` to attach a session, `$ tmux attach` could do the trick.
+`$ tmux attach-session` to attach a session, `$ tmux attach` could do the trick.
 
 Most aliases come to mind via intuition and are a lot friendlier than typing the
 full hyphenated commands.
@@ -69,7 +69,7 @@ patterns.
 For instance, you need not type `$ tmux attach-session` every time. First,
 there's the [alias](#aliases) of `$ tmux attach`, but additionally, more
 concise commands can be used if they partially match the name of the command or
-the target. tmux' pattern matching allows `$ tmux attac`, `$ tmux att`, `$ tmux at`
+the target. tmux's pattern matching allows `$ tmux attac`, `$ tmux att`, `$ tmux at`
 and `$ tmux a` to reach `$ tmux attach`.
 
 Every tmux command has shorthands; let's try this for `$ tmux new-session`:
@@ -253,7 +253,7 @@ Let's try to output it:
     $ tmux list-windows -F "#{window_id} #{window_name}"
     > @0 zsh
 
-Here's a cool trick; list all panes with the x and y coordinates of the cursor
+Here's a cool trick to list all panes with the x and y coordinates of the cursor
 position:
 
 {language=shell, line-numbers=off}
@@ -282,7 +282,7 @@ Pane variables: `cursor_x`, `cursor_y`, `pane_active`, `pane_current_command`,
 
 This book focuses on separating the concept of server, sessions,
 windows, and panes. With the knowledge of targets and formats, this
-separation takes shape in tmux' internal attributes. If you `list-panes` all
+separation takes shape in tmux's internal attributes. If you `list-panes` all
 variables up the ladder, including window, session and server variables are
 available for the panes being listed. Try this:
 
@@ -403,10 +403,10 @@ Output of cal(1).](images/10-scripting/send-keys-cal.png)
 
 `$ tmux capture-pane` will copy a panes' contents.
 
-By default, the contents will be saved to tmux' internal clipboard, the *paste
+By default, the contents will be saved to tmux's internal clipboard, the *paste
 buffer*. You can run `capture-pane` within any pane, then navigate to an
 editor, paste the contents (don't forget to `:set paste` and go into insert mode
-with `i` on vim), and save it to a file. To [paste](#clipbpard), use `Prefix` +
+with `i` in vim), and save it to a file. To [paste](#clipboard), use `Prefix` +
 `]` inside the pane you're pasting into.
 
 You can also add the `-p` flag to print it to [stdout](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29).
@@ -429,7 +429,7 @@ To check what's inside:
     $ cat ./test
 
 Like with `send-keys`, [targets](#targets) can be specified with `-t`. Let's
-copy a pane into tmux' clipboard ("paste buffer") and paste it into a text
+copy a pane into tmux's clipboard ("paste buffer") and paste it into a text
 editor in a third pane:
 
 ![Top-left: Listing panes, Bottom-left: Capturing pane output of top-left pane,
@@ -446,10 +446,10 @@ a powerful way of retrieving information on its objects between `list-panes`,
 `list-windows` and `list-sessions` and formats. This makes tmux not only
 accessible and configurable, but also scriptable.
 
-The ability to target information explicitly and reliably down to the point of
-tracking a pane by its ID and collecting its pane contents, even sending in
-keys. Used by the skilled programmer, opening the possibility of orchestrating
-the terminals in ways that were previously unrealistic; anything from niche
+The ability to retrieve explicitly and reliably, from session the sesson down to
+a pane. All it takes is a pane's ID to capture its contents or even send it
+keys. Used by the skilled programmer, scripting tmux can facilitate orchestrating
+terminals in ways previously deemed unrealistic; anything from niche
 shell scripts to monitor and react to behavior on systems to high-level,
 intelligent and structured control via object oriented libraries, like
 [libtmux](https://libtmux.git-pull.com).
@@ -458,6 +458,7 @@ In the next chapter, we delve into optimizations that showcase the latest
 generation of unix tools that build upon old, time-tested concepts, like [man pages](https://en.wikipedia.org/wiki/Man_page)
 and [piping](https://en.wikipedia.org/wiki/Pipeline_(Unix)), while maintaining
 portability across differences in platforms and graceful degradation to ensure
-development tooling works on machines missing optional tools. In addition, a
-class of powerful, high-level applications that leverage tmux' scripting
-capabilities to consistently build tmux workspace via declarative configurations.
+development tooling works on machines missing optional tools. Also, the chapter
+will introduce *session managers*, a powerful, high-level tool leveraging tmux's
+scripting capabilities to consistently load workspace via a declarative
+configuration.

manuscript/11-tips-and-tricks.md

@@ -2,9 +2,9 @@
 
 ## Read the tmux manual in style
 
-`$ man tmux` is the command to load up the "[man page](https://en.wikipedia.org/wiki/Man_page)"
-for tmux. You can do the same to find instructions for any command or entity
-with a manpage entry; here's two fun ones:
+`$ man tmux` is the command to load up the man page for tmux. You can do the
+same to find instructions for any command or entity with a manpage entry; here
+are some fun ones:
 
 {language=shell, line-numbers=off}
     $ man less
@@ -127,7 +127,7 @@ snippet in conjunction with a [session manager](#session-manager):
       entr -c go test ./...; else go test ./...; fi
 
 If the project is a team or open source project, where a user never used the
-command before and could missing a required software package, we can give
+command before and could be missing a required software package, we can give
 a helpful message. This shows a notice to the user to install entr if not
 installed on the system:
 
@@ -225,7 +225,7 @@ panes in a certain order. In addition, there's the burden of assuring the shell
 scripts are portable.
 
 A declarative configuration in YAML or JSON configuration abstracts out the
-commands, layout, and options of tmux. It'd prevent the mistakes and repetition
+commands, layout, and options of tmux. It prevents the mistakes and repetition
 scripting entails. These applications are called tmux *session managers*, and in
 different ways, they programmatically create tmux workspaces by running a
 series of commands based on a config.
@@ -237,8 +237,8 @@ Ruby. There's also [tmuxomatic](https://github.com/oxidane/tmuxomatic), where
 you can "draw" your tmux sessions in text and have tmuxomatic build the layout.
 
 I sort of have a home team advantage here, as I'm author of [tmuxp](https://github.com/tony/tmuxp).
-I wrote it, already having used teamocil and tmuxinator, but with many more
-features. For one, it builds on top of [libtmux](https://github.com/tony/libtmux),
+Already having used teamocil and tmuxinator, I wrote my own in python instead of
+ruby, with many more features. For one, it builds on top of [libtmux](https://github.com/tony/libtmux),
 a library which abstracts tmux [server](#server), [sessions](#sessions),
 [windows](#windows) and [panes](#panes) to build the state of tmux sessions. In
 addition, it has a naive form of session freezing, support for JSON, more
@@ -284,10 +284,10 @@ paths](#troubleshoot-site-paths) in the appendix.
 I've dusted off a C++ space shooter and a new go webapp I've been playing with.
 They're licensed under MIT so, you can use them, copy and paste from them, etc:
 
-- c++14 [space shooter minigame](https://github.com/tony/tot-cpp-shmup) - side
+- C++14 [space shooter minigame](https://github.com/tony/tot-cpp-shmup) - side
   scrolling [shmup](https://en.wikipedia.org/wiki/Shoot_'em_up) demo (sdl2,
-  cmake, json resource manifests, linux/BSD/OS X compatible)
-- golang [tmux web frontend](https://github.com/tony/tot-go-webapp) - display
+  cmake, json resource manifests, Linux/BSD/OS X compatible)
+- Go [tmux web frontend](https://github.com/tony/tot-go-webapp) - display
   current tmux session and window information via browser ([gin](https://github.com/gin-gonic/gin),
   [bower](https://bower.io/))
 

manuscript/12-takeaway.md

@@ -6,19 +6,19 @@ your brain around concepts. You do not have to understand the intricacies of
 tmux, let alone the terminal, in a single sitting. Acclimation happens over
 time.
 
-tmux' userbase varies in skill level. Some readers of this book may have just
-learned how to use the Prefix key yesterday. Others are looking to tweak their
+tmux's userbase varies in skill level. Some readers of this book may have just
+learned how to use the `Prefix` key yesterday. Others are looking to tweak their
 configurations and host it in their "dot files" on github. There also exists a
-very clever hacker, who utilizes the advanced scripting capabilities tmux
+very clever hacker who utilizes the advanced scripting capabilities tmux
 offers to pilot the terminal in ways previously thought impossible.
 
 We've covered the [server](#server), [session](#sessions), [window](#windows),
-and [pane](#panes) concepts. Panes are shells, aka pseudoterminals or
-PTYs. The command system. That [configurations](#config) are basically a file
+and [pane](#panes) concepts. Panes are shells, AKA pseudoterminals or
+PTYs. The command system. That [configuration](#config) is basically a file
 filled with commands. An overview of the [target](#targets) system lets
 you specify objects to interact with tmux commands. A breeze through [formats](#formats),
-a template system with variables to retrieve information on tmux' current state.
-How to [send keystrokes](#send-keys) and [copy from tmux panes](#capture-pane)
+a template system with variables to retrieve information on tmux's current
+state. How to [send keystrokes](#send-keys) and [copy from tmux panes](#capture-pane)
 programmatically. A lot of [terminal tricks](#tips-and-tricks) that work across
 platforms and well with tmux, including a [file watching workflow](#file-watching)
 to run linting, testing, and build commands on file changes. [Two permissively licensed open source projects](#example-projects)