• Understand regular version control
• Understand distributed version control

Along with a book, tutorial and cheatsheet, here are the insights that helped git click.

There’s a staging area!

Git has a staging area. Git has a staging area!!!

Yowza, did this ever confuse me. There’s both a repo (”object database”) and a staging area (called “index”). Checkins have two steps:

• git add foo.txt
  • Add foo.txt to the index. It’s not checked in yet!
• git commit -m "message"
  • Put staged files in the repo; they’re now tracked
  • You can “git add --update" to stage all tracked, modified files

Why stage? Git’s flexible: if a, b and c are changed, you can commit them separately or together.

But now there’s two undos:

• git checkout foo.txt
  • Undo local changes (like svn revert)
• git reset HEAD foo.txt
  • Remove from staging area (local copy still modified).

Add and commit, add and commit — Git has a rhythm.

Branching is “Save as…”

Branches are like “Save as…” on a directory. Best of all:

• Easily merge changes with the original (changes tracked and never applied twice)
• No wasted space (common files only stored once)

Why branch? Consider the utility of “Save as…” for regular files: you tinker with multiple possibilities while keeping the original safe. Git enables this for directories, with the power to merge. (In practice, svn is like a single shared drive, where you can only revert to one backup).

Imagine virtual directories

I see branches as “virtual directories” in the .git folder. While inside a physical directory (c:\project or ~/project), you traverse virtual directories with a checkout.

• git checkout master
  • switch to master branch (”cd master”)
• git branch dev
  • create new branch from existing (”cp * dev”)
  • you still need to “cd” with “git checkout dev”
• git merge dev
  • (when in master) pull in changes from dev (”cp dev/* .”)
• git branch
  • list all branches (”ls”)

My inner dialogue is “change to dev directory (checkout)… make changes… save changes (add/commit)… change to master directory… copy in changes from dev (merge)”.

The physical directory is a scratchpad. Virtual directories are affected by git commands:

• rm foo.txt
  • Remove foo.txt from your sandbox (restored if you checkout the branch again)
• git rm foo.txt
  • Remove foo.txt from current virtual directory
  • Gotcha: you need to commit that change!

Know the current branch

Just like seeing your current directory, put the current branch in your prompt!

In my .bash_profile (modified from here):

parse_git_branch() {
    git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/'
}

export PS1="\[\033[00m\]\u@\h\[\033[01;34m\] \W \[\033[31m\]\$(parse_git_branch) \[\033[00m\]$\[\033[00m\] "

Visualize your branch structure

Git leaves branch organization to you. Nvie.com has a great branch strategy:

• Have a mainline (master). Mentally it’s on the far right.
• Create branches (master -> dev) and subbranches (dev -> featureX). The further from master, the crazier.
• Only merge with neighbors (master -> dev -> feature X, or featureX -> dev -> master)

Stay sane by choosing a branch layout up front. I have a master tracking a svn project, and dev for my own code. In general, master is clean so I can branch anytime for one-off fixes.

Understand local vs. remote

Git has local and remote commands; seeing both confused me (”When do you checkout vs. pull?”). Work locally, syncing remotely as needed.

Local data

• git init
  
  • create local repo
  • use git add/commit/branch to work locally

Remote data

• git remote add name path-to-repo
  • track a remote repo (usually “origin”) from an existing repo
  • remote branches are “origin/master”, “origin/dev” etc.
    
• git branch -a
  • list all branches (remote and local)

• git clone path-to-repo
  • create a new local git repo copied from a remote one
  • local master tracks remote master
• git pull
  • merge changes from tracked remote branch (if in dev, pull from origin/dev)
• git push
  • send changes to tracked remote branch (if in dev, push to origin/dev)

Why local and remote? Subversion has central checkins, so you avoid committing unfinished work. With git, local commits are frequent and you only push when ready.

GUIDs are GOOD

Git addresses information by a hash (GUID) of its contents. If two branches are the same, they have the same GUID (and vice versa).

Why’s this cool? We can create branches independently, merge them, and have a common GUID. No central numbering needed. Usually, we just compare the first few digits: “Are you on a93?”.

Tips & Tricks

For your .gitconfig:

[alias]
        ci = commit
        st = status
        co = checkout
        oneline = log --pretty=oneline
        br = branch
        la = log --pretty=\"format:%ad %h (%an): %s\" --date=short

There are some GUI tools for git, but I prefer to learn via the command line. Git is opinionated software (which I like), and analogies help me understand its world view.

• The “bag of formulas”: memorize ‘em and move on
• The anal-retentive, rigorous treatment: written by math robots, for math robots!
• The happy smiles tour: oversimplifications without examples (Calculus helps scientists solve problems!)

No, nyet, nein! I know what I need: intuition (What does it really mean?) followed by examples to back it up. I want a calculus series that lets calculus be calculus — wild, interesting, and fun.

The Explanatory Approach

I started writing in a vacuum, but realized I don’t remember calculus. I need a refresher — in fact, I need the insights I want to share! These articles are for us both (it’s what I’d want to relearn the subject), and here’s my approach:

• I’m reading Elementary Calculus: An Infinitesimal Approach [free pdf]. It teaches calculus using its original approach (infinitesimals), not the modern limit-based curriculum. My goal is intuition, so this works well.

• As I study the chapters, I’ll share the insights I find and the concepts I struggled with.

• I’ll sprinkle examples along the way. They’re a gut check, not the focus (if you want practice problems, the book has plenty).

It’s a lack of insights, not information, that makes calculus hard. We don’t need another course repeating the definitions that confused us the first time (Here’s the definition of a limit, again!).

We shouldn’t be struggling with the true meaning of a subject centuries after its invention. This is my intuition-laced hat in the ring.

The Calculus Articles

The goal is to be concise, informal, and fun. Dabble, skim and ignore the examples if needed — focus on the insights. The elegance of calculus can be appreciated progressively: we don’t need astrophysics to enjoy a starry night.

Learning Math

• Developing Your Intuition For Math

Calculus Overview

• Prehistoric Calculus: Discovering pi
• A Gentle Introduction To Calculus

Small numbers: Limits and Infinitesimals

• Learning Calculus: Overcoming Our Artificial Need for Precision
• Understanding the need for small numbers (in progress)

Measuring Changes: Derivatives

Accumulating Changes: Integrals

• A Calculus Analogy: Integrals as Multiplication

This post is the table of contents for the series. Happy math.

• Networking is about communication
• Text is the simplest way to communicate
• Protocols are standards for reading and writing text

Beneath the details, networking is an IM conversation. Here's what I wish someone told me when learning how computers communicate.

TCP: The Text Layer

The Transmission Control Protocol (TCP) provides the handy illusion that we can "just" send text between two computers. TCP relies on lower levels and can send binary data, but ignore that for now:

• TCP lets us Instant Message between computers

We IM with Telnet, the 'notepad' of networking: telnet sends and receives plain text using TCP. It's a chat client peacefully free of ads and unsolicited buddy requests.

Let's talk to Google using telnet (or putty, a better utility):

telnet google.com 80
[connecting...]
Hello Mr. Google!

We connect to google.com on port 80 (the default for web requests) and send the message "Hello Mr. Google!". We press Enter a few times and await the reply:

<html>
...
<h1>Bad Request</h1>
Your client has issued a malformed or illegal request
...
</html>

Malformed? Illegal? The mighty Google is not pleased. It didn't understand us and sent HTML telling the same.

But, we had a conversation: text went in, and text came back. In other words: 

Protocols: The Forms To Fill Out

Unstructured chats is too carefree -- how does the server know what we want to do? We need a protocol (standard way of communicating) if we're going to make sense.

We use protocols all the time

• Putting to: and from: addresses in certain places on an envelope
• Filling out bank forms (special place for account number, deposit amount, etc.)
• Saying "Roger" or "10-4" to indicate a radio request was understood

Protocols make communication clear.

Case Study: The HTTP Protocol

We see HTTP in every url: http://google.com/. What does it mean?

• Connect to server google.com (Using TCP, port 80 by default)
• Ask for the resource "/" (the default resource)
• Format the request using the Hypertext Transport Protocol

HTTP is the "form to fill out" when asking for the resource. Using the HTTP format, the above request looks like this:

GET / HTTP/1.0

Remember, it's just text! We're asking for a file, through an IM session, using the format: [Command] [Resource] [Protocol Name/Version].

This command is "IM'd" to the server (your browser adds extra info, a detail for another time). Google's server returns this response:

HTTP/1.0 200 OK
Cache-Control: private, max-age=0
Date: Sun, 15 Mar 2009 03:13:39 GMT
Expires: -1
Content-Type: text/html; charset=ISO-8859-1
Set-Cookie: PREF=ID=5cc6...
Server: gws
Connection: Close

<html>
(Google web page, search box, and cute logo)
</html>

Yowza. The bottom part is HTML for the browser to display. But why the junk up top?

Well, suppose we just got the raw HTML to display. But what about errors: if the server crashed, the file wasn't there, or google just didn't like us?

Some metadata (data about data) is useful. When we order a book from Amazon we expect a packing slip describing the order: the intended recipient, price, return information, etc. You don't want a naked book just thrown on your doorstep.

Protocols are similar: the recipient wants to know if everything was OK. Here we see infamous status codes like 404 (resource not found) or 200 (everything OK). These headers aren't the real data -- they're the packing slip from the server.

Insights From Protocols

Studying existing, popular systems is a great way to understand engineering decisions. Here are a few:

Binary vs Plain Text

Binary data is more efficient than text, but more difficult to debug and generate (how many hex editors do you know to use?). Lower-level protocols, the backbone of the internet, use binary data to maintain performance. Application-level protocols (HTTP and above) use text data for ease of interoperability. You don't have religious wars about endian issues with HTTP.

Stateful vs. Stateless

Some protocols are stateful, which means the server remembers the chat with the client. With SMTP, for example, the client opens a connection and issues commands one at a time (such as adding recipients to an email), and closes the connection. Stateful communication is useful in transactions that have many steps or conditions.

Stateless communication is simpler: you send the entire transaction as one request. Each "instant message" stands on its own and doesn't need the others. HTTP is stateless: you can request a webpage without introducing yourself to the server.

Extensibility

We can't think of everything beforehand. How do we extend old protocols for new users?

HTTP has a simple and effective "header" structure: a metadata preamble that looks like "Header:Value".

If you don't recognize the header sent (new client, old server) just ignore it. If you were expecting a header but don't see it (old client, new server), just use a default. It's like having an "Anything else to tell us?" section in a survey.

Error Correction & Reliability

It's the job of lower-level protocols like TCP to make sure data is transmitted reliably. But higher-level protocols (like HTTP) need to make sure it's the right data. How are errors handled and communicated? Can the client just retry or does the server need to reset state?

HTTP comes with its own set of error codes to handle a variety of situations.

Availability

The neat thing about networking is that works on one computer. Memcached is a great service to cache data. And guess what? It uses plain-old text commands (over TCP) to save and retrieve data.

You don't need complex COM objects or DLLs - you start a Memcached server, send text in, and get text out. It's language-neutral and easy to access because any decent OS supports networking. You can even telnet into Memcached to debug it.

Wireless routers are similar: they have a control panel available through HTTP. There's no "router configuration program" -- you just connect to it with your browser. The router serves up webpages, and when you submit data it makes the necessary configuration changes.

Protocols like HTTP are so popular you can assume the user has a client.

Layering Protocols

Protocols can be layered. We might write a resume, which is part of a larger application, which is stuffed into an envelope. Each segment has its own format, blissfully unaware of the others. Your envelope doesn't care about the resume -- it just wants the to: and from: addresses written correctly.

Many protocols rely on HTTP because it's so widely used (rather than starting from scratch, like Memcached, which needs efficiency). HTTP has well-understood methods to define resources (URLs) and commands (GET and POST), so why not use them?

Web services do just that. The SOAP protocol crams XML inside of HTTP commands. The REST protocol embraces HTTP and uses the existing verbs as much as possible.

Remember: It's All Made Up

Networking involves human conventions. Because plain text is ubiquitous and easy to use, it is the basis for most protocols. And TCP is the simplest, most-supported way to exchange text.

Remembering that everything is a plain text IM conversation helps me wrap my head around the inevitable networking issues. And sometimes you need to jump into HTTP to understand compression and caching.

Don't just memorize the details; see protocols as strategies to solve communication problems. Happy networking.