The books did make me think. A lot. A lot about a tool I use everyday…
git (http://git-scm.com).

Git is sweet tool. But, the UI could use some love.

The UI can be confusing and inconsistent for newbies. In fact, even after three years of using git, there are commands I still find confusing (do I want git revert or git reset… and does it need –hard, HARD, –cached, HEAD, –, or  something else?).

An interface should never be a by-product of the implementation of the system. This is where the Git UI goes wrong.

The command git reset is a good example. I use git reset to undo things. But, its called “reset” and has a bunch of strange parameters which have to do with making writes to the git index. In order to undo changes properly, the reset command requires the user to have a clear understanding of the guts of the git index. This should not be the case for a common command, like undo.

# Why not replace things like: git reset HEAD -- file with:
> git unstage

If we make all the “resetting” and funny “HARD — HEAD” parameters happen behind the scenes, then we make the user happier. A lot happier.

Here are a few other small irks I have with the git UI:

• I have some files I want to stage. Do I want git add ., git add -u, or git add -A? Which does what again? Confused.
• Oh geez. I just staged something by accident. How do I unstage it? Its git reset? Or is it git revert? Do I do a HARD, –, HEAD, FILE, or something else? Brain damage.
• I want to see my changes. git diff? git diff HEAD? or git diff –cached? why not git diff CACHED? Grrrr….
• git status is cluttered with commands telling me how to undo things “use git reset HEAD <file> to unstage”. If the commands were easy enough to remember in the first place, we would not need to clutter the status output with reminders. And, what does “changed but not updated mean”? I did update my file! Do you mean “changed but not staged”? Lastly, I would like to humbly request a few fewer “#” characters. Just a few. Please.

Here is my shot at re-creating a few parts of the Git UI. My hope is that all of these commands become part of git one day and that git becomes easier for new users and forgetful intermediates like me.

Staging files

# Stage all changes, and file deletions. Leave unknown files alone.
# Instead of git add -u, just type:
> git stage

# Stage just one file change or deletion.
# Instead of git add FILE and git rm FILE, just type:
> git stage FILE

Unstaging Files

Ooops. I staged a changed that I do not want to commit.

# Remove one file from the stage.
# Instead of git reset HEAD -- file, just type:
> git unstage FILE

# unstage all the files you have in the stage right now.
# Instead of git reset HEAD, just type:
> git unstage

Undoing changes I have made:

Ok. I tried something. It does not work. Just get me back to the last commit.

# Undo all the changes I made to working directory.
# Automatically save the user's work in a stash, then
# Instead of git stash; git reset --hard HEAD, just type:
> git retreat
All files changed back to their state at the last commit.
Your work has been saved in stash@{1}. 

# Just undo the changes I made to one file.
# Automatically save a stash of the user's work first
# Rather than git checkout FILE (side note: why is it not git reset FILE? or is it?)
# Instead, just type:
> git retreat FILE
The file was changed back to the it's state at last commit.
Your work has been saved in stash@{1}.

Deleting Files

Let’s get rid of git rm. Lets not even tell newbies about it. Just delete files you want from your project, then:

# smart enough to stage files you have removed as well!!!!
> git stage
> git stage FILE

Status

More readable. Less # signs. Less instructions.

> git status

Staged for commit:
    M daemon.c
    N test.txt

Unstaged Changes (will NOT be committed):
    M hello.c
    ? new.c

Nice and clean. No reminders about how to undo things… you already know that: git undo. And, no # signs!!

Automatic Setup

The first time I run git from a new computer I am most often greeted with an error. Not a very friendly way to great new users. The message says that I have not set my email and user name.

If this error occurs, shouldn’t git just ask me for this information and proceed with the command I typed? Yep, it should.

# my first ever commit with GIT! Don't greet me with an error.
> git commit -m "yippeee git!"

Howdy! So that git can give you credit for changes you make
    Please enter your name? Jon Saints
    Please enter your email? email@gmail.com
Thank you! Committing...

This replaces the more confusing error message that git shows users now:

Error 123: Look! Another stupid user is _trying_ to learn git. 

You should have known to type this first:
> git config --global user.name "Jon Saints"
> git config --global user.email "gmail@gmail.com"

DUFUS!! Just give up now. Seriously.

Switching branches

# I switch branches with the checkout command. Its ok, but what if we had:
> git switch BRANCH

Showing things I have changed

This is one of the most important parts of git. And, it is confusing.

# What is the output? Can you remember which is which?
# git diff
# git diff HEAD
# git diff --cached or git diff CACHED?

# Instead we can... 

# Show all changes from the last commit
> git diff
# or
> git diff HEAD

# Show difference between the stage and my code
> git diff STAGE

# Difference between my stage and last commit
> git diff STAGE HEAD

# Difference between two branches or revisions
> git diff branch1 branch2
> git diff AD34E BCDE543

Deleting a branch

# Let's be consistent with git remote command. Instead of git branch -d
> git branch rm BRANCH

Where to from here?

I am going to make a small python wrapper to try out these commands. It will be called gum. And, it will just write git commands for you.

gum = Git User (interface) Makeover.

“gum unstage” here we come! The code is on github: https://github.com/saintsjd/gum

Comments welcome.

Now, let me say this: There have been many times, since I left college, where I wanted to gain a new skill to start a business or to expand my realm of possibility. Times where I wanted something a little cheaper than a graduate degree, a little more structured than teaching my self, and a lot more flexible than a semester. There are certainly times where going back to college for a another full blown rite of passage just is not a fit.

So what is? Is there a more a-la-carte journey out there? A way to get bursts of learning without a full degree?

A couple sources have inspired my thinking on the topic recently:
1) Khan Academy: Revolutionary. Access to high quality lectures on wide range of topics for anyone with an internet connection. Khan believes in flipping classroom. This means lectures by video at home and homework collaboratively in the classroom. http://www.youtube.com/watch?v=HkMS6Glswig

2) Book: Reality is Broken by Jane Mcgonigal (http://www.amazon.com/Reality-Broken-Games-Better-Change/dp/1594202850). McGonigal Explains the idea of Leveling Up in education. Rather than semesters and grades subjects are given Levels and open time frames.

With Grades. Anything but an “A” means you fell short. A letter grade of “C” means the student only got about half as far as the teacher thought they should in a time frame (semester) that was set by the school.

Leveling up is different. Students progress at their own pace choosing their levels of expertise they want to obtain. Level 1 in chemistry might be “How not to blow yourself up in the kitchen”. Level 3 might be “Ace the AP Chem test”. Level 5 might be “wowzers… you just invented a new kind of compostable plastic”. You wear levels like you wear karate belts. There is no shame in any level. Some students have just journied farther than others.

My answer: A-la-Carte Education. Lab course series taught outside of colleges. Students pay per level and can come and go as they wish and continue from where they left off. Classes are all flipped: reading and lectures at home. Collaboartive problem solving (homework) in a weekly meeting with the teacher and other students.

HSA health plans allow you to open a Health Savings account and save $ tax free to use for medical expenses. So, the less you pay in premiums, the more you will have to save.

So, how high of a deductible should you choose? What is the best balance between coverage and savings?

The answer depends mostly on how much you have budgeted to spend on health insurance each month.

Start with the amount you have to spend on health related expenses each month. For my wife and I its $700.

Next, look at some Health Plans. You will want to look at two things:

1. How much you can save each month and use toward medical expenses before your deductible kicks in
2. What happens in a worst case scenario. How much monthly will you have to pay if you are seriously injured and need to pay both your monthly premium, plus the full deductible amount.

The spread sheet I used to determine these amounts is here:

https://spreadsheets.google.com/pub?hl=en&hl=en&key=0AipucNLg02ekdGlLOE01Vld6bG5MVFVYNF9HNmlVbGc&output=html

Please copy this spreadsheet and fill in your own numbers

Here are my conclusions… keep in mind I these are for coverage for myself and my wife in Colorado. Numbers for bigger families in other states will vary greatly. But, the process for choosing the right plan will be the same.

• if my monthly health budget were < $250: There is no health plan that I could afford. I should seek gov’t help
• $300 monthly health budget: Go with the $10,000 deductible plan. Its all that can be afforded. Some coverage is better than none.
• $400 monthly health budget: Choice to make here. I can save 18% of my deductible each year on the $10,000 plan. But my worst case monthly cost is $1083. Safer bet is $7000 plan. There I save 4% less towards my deductible each year, but in the worst cast only need to pay $899 per month.
• $500 monthly health budget: Clear choice here is the $7000 deductible plan. Save the highest percent each year towards deductible 32% and have a lower worst case payment of $899 per month.
• $600 monthly health budget: Choose the $5000 deductible plan. Over the course of the year you will save the same percent 49% towards your deductible as the $7000 plan, but you will have lower worst case monthly costs of $811
• $700 monthly health budget: Choose the $5000 deductible plan. Over the course of the year you save the most 73% towards your deductible and have lower worst case monthly costs of $811
• $800 monthly health budget: Still choose the $5000 plan. Will save 97% towards deductible and have $811 worst case. Savings of going to more expensive $2500 plan is only $9 in worst case $802.
• $900 and above budget: Still choose the $5000 plan. Will save more towards deductible and have $811 worst case. Savings of going to more expensive $2500 plan is only $9 in worst case $802.

Summary: There are no cases were the lowest deductible plan makes sense. There is also only one case where the highest deductible plan make sense; (when its your only option for health insurance). All other cases its best to choose between the two middle plans. The best choice there depends on how much risk you want to take on.

Curious to see if you all find the same conclusions.

Lets fix that…. Here is a quick heroku-ish git deployment workflow for your PHP applications. We will be using WordPress for this example. The same steps can be adapted for Drupal or any other PHP application.

Our goal is to development and test new features, themes, and plugins for WordPress locally on our development machine. When changes are working properly, we want to deploy them to our live site with one command:

git push origin master

#1: Set up password-less login to your webserver with SSH keys

To run deployments we will need to access our live webserver without a password. Follow the steps  in Setting up ssh public keys to login to webserver without a password.

For each user or machine from which you want to allow deploys you will need to install its SSH key using the steps above.

#2: Setup Code Repository on the Webserver

I connect to the webserver via SSH. My home directory is /home/saintsjd.

I have a /home/saintsjd/www folder for my website and PHP files. I also have a /home/saintsjd/code folder for my git repositories.

cd into /home/saintsjd/code and create a folder called blog.git

cd /home/saintsjd/code
mkdir blog.git

Next, initialize a bare git repository

cd blog.git
git init --bare blog.git

This gives me a git repository to store my code at /home/saintsjd/code/blog.git. I then disconnect from the SSH connection to the webserver.

#3: Setup Development Box

I have php, mysql, and apache running locally on my laptop. I create my WordPress themes, plugins, and updates on my laptop. After I test them, I deploy them to the live webserver for the world to see.

My local website folder is /home/jon/Website. To get started I clone my git repo locally:

git clone ssh://saintsjd@saintsjd.com/home/saintsjd/code/blog.git ./blogdev

This give me:

/home/jon/Website/blogdev

Now i can start filling in code!

Into the /home/jon/Website/blogdev/ folder I copy in all the files for WordPress and run the installer.

Next, I need to add a gitignore file to the project. I use the one here. https://github.com/github/gitignore/blob/master/Wordpress.gitignore. I copy the contents of that file into a .gitignore file in /home/jon/Website/blogdev/.gitignore. I then:

git add .
git commit -m "inital commit"

To send my changes to the server I type:

git push origin master

#4: Setup Live Webserver

Now I install WordPress on my server. I SSH to my server. There my website directory is /home/saintsjd/www. I need to remove this folder so I backup everything in this directory.  Then I remove it and recreate it using git clone. I type:

rm -rf /home/saintsjd/www
git clone /home/saintsjd/code/blog.git /home/saintsjd/www

I then browse to my website http://www.saintsjd.com and run the wordpress installer so the database gets installed on the server.

IMPORTANT: Protect your .git repository from prying eyes

I don’t really want others reading my source code from the git repository via http://www.saintsjd.com/.git/

I prevent this by running:

chmod -R og-rx /home/saintsjd/www/.git

I also add a .htaccess file to the .git folder containing:

Deny from all

#5: Automated Deployment Script

Now that wordpress is installed on both my local machine and my live webserver, I want to be able to deploy any changes I make on my local copy with one git push command. I can do this using a Git hook.

I SSH to my webserver and create a file /home/saintsjd/code/blog.git/hooks/post-receive

touch /home/saintsjd/code/blog.git/hooks/post-receive

I make the file executable

chmod u+x /home/saintsjd/code/blog.git/hooks/post-receive

Then I edit the file

nano -w /home/saintsjd/code/blog.git/hooks/post-receive

and place this code in it (adjusting the config variables to match your server settings)

#!/bin/bash
#CONFIG
LIVE="/home/saintsjd/www"

read oldrev newrev refname
if [ $refname = "refs/heads/master" ]; then  
  echo "===== DEPLOYING TO LIVE SITE ====="  
  unset GIT_DIR  
  cd $LIVE  
  git pull origin master  
  echo "===== DONE ====="
fi

#6 Let the (heroku-like) Fun Begin: Automated Deployment for WordPress

Now that everything is setup. I am free to develop new themes, install new plugins and update on my local development box. Once everything is working properly locally commit and push. The post-receive hook automatically deploys the code changes to my live webserver for me.

Here are my steps:

1. Make changes to my local site’s code: new theme, new plug-in, etc
2. test, test and test so more!
3. When I am happy I commit to the local git repository:

   git add .
   git commit -m "new theme css for header"

4. I push and deploy to the server using one command:

   git push origin master

5. After the post-receive hook moves the new code to the live website. I open http://www.saintsjd.com/wp-admin on the live server to trigger and database updates that need to run

That’s it… heroku-ish git deployment for WordPress websites.

I subscribe to the Economist print edition usually for about 6 months out of the year.

Websites:

• New York Times
• Lifehacker
• Clarin
• Wall Street Journal
• ESPN
• The Economist Online
• Marketplace
• NPR Hourly News Summary
• Harvard Business Review
• BBC News
• Al Jazeera
• BBC Mundo Podcasts
• TED
• Fox News

UPDATE: This post is out of date. Please see the new and improved version of this page Automated Deployment of WordPress using git

——-

Continuous Deployment is a strategy you’ll want to implement for any successful web project. According to Eric Reis, “It’s a process whereby all code that is written for an application is immediately deployed into production. The result is a dramatic lowering of cycle time and freeing up of individual initiative. It has enabled companies I’ve worked with to deploy new code to production as often as fifty times every day.”

This article describes one method for configuring a continuous deployment infrastructure using git, fabric, and SSH. Its fairly lightweight and should work with basic hosting systems.

Our goal here is to create new features locally on a development machine, commit happy changes to a code repository, and finally deploy the changes to a live web server with ease using server side scripts. It makes deploying new changes to a live wordpress website so easy you’ll want to do it 50 times a day!

Install Deployment Tools on your Dev Machine:

I use fabric for all of my non-rails applications (PHP, Python, etc). Fabric allows you to execute command on remote servers by running a local script on your machine.

Its available at http://docs.fabfile.org/

To install on my local Ubuntu Linux development machine I just:

sudo apt-get install fabric

Set up SSH keys

To run deployments we will need to access our remote SSH server without a password. Follow the steps  in Setting up ssh public keys to login to SSH servers without a password.

For each user or machine from which you want to allow deploys you will need to install its SSH key using the steps above.

Use git to Setup Code Repositories

I use two separate git repositories: one for my wordpress website and another to track changes to my fabric deployment scripts. I store my repositories on my web server in the folder

/home/jon/code/saintsjd.com
/home/jon/code/saintsjd.com/www.git (is my wordpress website git repo)
/home/jon/code/saintsjd.com/deploy.git (is my repo for deployment scripts)

So I cd into /home/jon/code/saintsjd then:

git init --bare www.git
git init --bare deploy.git

Setup a Local Development Space

I have php, mysql, and apache running locally on my development machine. My local website folder is /home/jon/Website. There I create a folder /home/jon/Website/saintsjd.com. I then clone my git repos locally:

git clone ssh://jon@saintsjd.com/home/jon/code/saintsjd.com/deploy.git ./deploy
git clone ssh://jon@saintsjd.com/home/jon/code/saintsjd.com/www.git ./www

This give me:

/home/jon/Website/saintsjd.com/www
/home/jon/Website/saintsjd.com/deploy

Now i can start filling in code!

Install WordPress in Dev Space

Into the /home/jon/Website/saintsjd.com/www/ folder I copy in all the files for wordpress and run the wordpress installer. After WP is installed properly on my local machine I initialize a git repository to start tracking my code.

First, I need to add a gitignore file to the project. I use the one here. https://github.com/github/gitignore/blob/master/Wordpress.gitignore. I copy the contents of that file into a .gitignore file in /home/jon/Website/saintsjd.com/www/.gitignore. I then:

git add .
git commit -m "inital commit"

To send my changes to the server I type:

git push origin master

Install WordPress on the server

Now I install wordpress on my server. I ssh to my server. There my website directory is /home/jon/public_html. I backup everything in this directory then I remove this directory and recreate it using git clone. I type:

rm -rf public_html
git clone /home/jon/code/saintsjd.com/www.git public_html

I then run the wordpress installer.

Writing the deploy scripts

With wordpress installed locally and on my server. I am ready to write a fabric deploy script to easily synchronize changes I make locally to my live version of wordpress on the web server.

On my development machine I:

cd /home/jon/Website/saintsjd.com/deploy

There I create fabfile.py and fill the file with the code below:

from fabric.api import *
env.hosts = ['jon@saintsjd.com']
WEBSITE_PATH = "/home/jon/public_html"

def deploy():
    with cd(WEBSITE_PATH):
        run('git pull')

You will need to change the env.hosts value to use your ssh login for your server. You will also need to change WEBSITE_PATH to reflect the path to your website on the server.

Now when ever we want to deploy changes to the live website we can just

1. commit our changes with git and push
2. go to the command line and

   fab deploy

If you want to (I do), you can get fancy and make a backup before each deployment. This is great in case something goes wrong. My fabfile.py with backups looks like:

from fabric.api import *

env.hosts = ['jon@saintsjd.com']
LIVE = "/home/jon/www/saintsjd.com"
BACKUPS = "/home/jon/backups/saintsjd.com"
MYSQL_USER = ""
MYSQL_PASSWORD = ""
MYSQL_DATABASE = ""

def deploy():
    backup()
    with cd(LIVE):
        run('git pull origin master')

def backup():
    run('mysqldump -u %s -p %s --add-drop-table --password=%s  > %s/saintsjd.com-database-current.mysql' % (MYSQL_USER, MYSQL_DATABASE, MYSQL_PASSWORD, BACKUPS) )
    run('/usr/bin/nice tar -czf %s/saintsjd-`date +%%Y%%m%%d%%H%%M%%S`.tar.gz %s/saintsjd.com-database-current.mysql %s' % (BACKUPS,BACKUPS,LIVE) )

With fabfile.py written and working I add it to my git repo and push to the server for safe keeping:

git commit -am “initial commit”
git push origin master

Protect your .git folder on the live website using .htaccess

I don’t really want others reading my git repository via http://www.saintsjd.com/.git/ I prevent this by running:

chmod -R og-rx /home/public_html/.git

I also add a .htaccess file to the .git folder containing:

Deny from all

Continuous deployment of WordPress using git and fabric

My continuous deployment for the website is all set. Now I

1. make changes to my local site’s code: new theme, new plug-in, etc
2. test, test test
3. when I am happy I commit to the local git repository
4. I push to the server
5. I then change directory into my ../deploy folder and run

   fab deploy

   on the command line to send the change to the live website

6. finally I open wp-admin on the live server to trigger and database updates that need to run

When you need to download copies of websites to browser at a later time offline use httrack.

Repositories created with “git init” command contain 2 things: the .git folder repository (or code history) and also real life working copies of your source code files. You can think of this type of repository as a working directory. Its a folder with code history stored in .git folder and all the source files as well. You can work in this directory changing source files and save your changes using the “git add” and “git commit” commands.

Bare repositories contain only the .git folder and no working copies of your source files. If you “cd” into a bare repository you find only the .git folder and nothing else. A bare repository strictly contains the version history of your code.

Why use one or the other?

Well, a working repository is for just that… working. Its where you will actually edit files, add files, delete files to create your project saving your changes to the local .git repo along the way. If you are starting a project in a folder which will contain your code as well as a git repo for tracking changes use “git init”. Also if you “git clone” a repository from some one else you will be given a working repository with the .git folder and copies of the working files.

A bare repository is for… sharing. Bare repositories are shared repos where developers can send their local changes from their working copies of projects to the world or to the rest of their team. By using the “git push” command, you are able to send changes in your local working copies of a project to a centralized shared bare repository. Other developers can then “git pull” to receive the changes that you made. If you are collaborating with a team of developers or you need to work on a project from multiple computers , then a bare git repository is what you need in between to coordinate the distributed development.

To summarize: the working directory created with “git init” or “git clone” is my local copy of a project. Its where I add my changes to a project’s code files and test. After I am happy I “git add” and “git commit”. Then I “git push” to a bare repository, usually on another server, so that other developers can access my changes. When I want to update my local working copy I “git pull” to receive the changes that other developers have made.

Once configured SSH keys can save you time and enable easier use of applications like Git. Below are steps for Mac and Linux users to create SSH keys and install them on remote servers for passwordless logins.

Create an SSH key on your local machine

From the command line type:

ls .ssh

If you see a file called id_rsa.pub listed, then you already have created a key. Skip to the next section called “Copying the key to the server”.

If you do not see id_rsa.pub listed. Lets create one. Type:

ssh-keygen -t rsa

Setting a password for your key is recommended, but it optional. Once the process completes, run:

ls .ssh

And verify that you have a id_rsa.pub file.

Copying the key to the server

There are two methods for copying the keyfile to the server. Ubuntu Linux has the easiest method. A special command ssh-copy-id. Go to the command line and try (change the username and server name):

ssh-copy-id username@servername.com

You’ll be prompted to accept the identity of the server. Say “yes”. Then enter your password. Once the file is copied, you are ready to login without passwords.

If your computer does not have the ssh-copy-id command you need to manually open the id_rsa.pub file in a text editor and copy its contents (this is your public key). Carefully paste the public key at the end of a file in your home directory on the server located at .ssh/authorized_keys2. If the .ssh directory and the authorized_keys2 files do not exist you can create them, but make sure permissions are set so others users cannot view the folder or files.

With your key installed you are ready to login without a password!

Login via SSH without a password

Go to the command line and type:

ssh username@servername.com

Your first time you may be asked to accept the identity of the server. Say “yes”. If your public key is installed correctly you will be able to login to the server without a password.

Any other SSH server you want to log into with a password… just install your public key id_rsa.pub on the server using the steps above.

UPDATE: This post is out of date. Please see the new and improved version of this page Automated Deployment of WordPress using git

——-

Distributed revision control systems are an excellent way to manage the source code of web applications. Currently I use git. In the past, I have used bzr and hg. All three great tools.

Git is now my favorite for a number of reasons.

While the tools are great at managing code and facilitating distributed development, it did take a while for me to find an efficient way to deploy my version controlled code to a live web server. The following is an outline of a simple workflow for developing and deploying web applications using distributed revision control systems. You could apply these methods to either bzr, hg, or git.

I keep development copies of the websites I manage for clients on my local machine. I develop and create new features locally on branched copies of the source code. When I complete and test a feature I commit the changes to the central code repository and deploy it to the live server using a few different methods.

Creating your code repository

A code repository is a place to save your code. Its important to not that the repository itself is not a functioning website. It is a file often on a completely different server than the live website and the development boxes. There are two options for creating a code repository. On is github.com. I use GitHub to store my open source projects. For projects with closed source code I store my repositories on server which allows ssh connections in a folder that is not accessible via the web. You can pay for a github account which allows you to create private repositories.

Creating an repository on Github.com
Follow the step here: http://help.github.com/

Creating a repository on your own SSH server
I will create my repository in a non-webaccessible directory on my live server. so… on my live server I will have:

/home/jon/public_html (my live website folder)
/home/jon/code (a private folder not accessible from the web to store my source code)

1. Log into the server via SSH
2. my home directory is /home/jon
3. I create a directory /home/jon/code for all my repositories /home/jon/code
4. cd into the code directory and type:

git init --bare drupaltest.git

Setting Up Local Development Website
Change directories on your local development computer into a web accessible directory. On my machine the local folder /home/jon/Website is accessible at http://localhost/jon/. So I open the terminal and run:

cd /home/jon/Website

Then:

git clone jon@saintsjd.com:code/drupaltest.git drupaltest

This command clones the repository to my local machine and creates a localfolder called drupaltest. I can now start adding files to it. Lets unzip a fresh copy of Drupal 7 and copy all the files into the drupaltest folder. I then browse to http://localhost/jon/drupaltest/ and I run the Drupal installer.

With drupal installed we are ready to start committing our code to our git repo.

We first need to create a .gitignore file in the root of our web application /home/jon/Website/drupaltest/.gitignore. This file tells git to ignore certain files. We want to keep our settings.php file out of the repository and our sites/default/files folder out of the repository because the settings and files on our development computer will be different from the settings.php and files on the live server. My .gitignore contains:

sites/default/files
sites/default/private
sites/default/settings.php

With /home/jon/Website/drupaltest/.gitignore created, I run:

git add .
git commit -m "initial commit"

I then send my code up to the repository on my server. Remember the repository is just a place to keep my code. It is not a live functioning website. We will create that live site later. To push the code to my respository I run

git push origin master

And I know the command was successful when I see something like:

Counting objects: 1099, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (1087/1087), done.
Writing objects: 100% (1099/1099), 2.81 MiB | 324 KiB/s, done.
Total 1099 (delta 119), reused 0 (delta 0)
To jon@saintsjd.com:code/drupaltest.git
* [new branch]      master -> master

Creating a Live Website from our Repository

The command in this section only need to be run once when you first setup your website. Like the install we ran locally we now need to run an Drupal install on our server to setup a separate database for live data. I ssh to my server and change directories into my public_html folder.

My code repo is stored on the same server as my live website but is in a folder that is not accessible from the web. Remember that i have:

/home/jon/public_html (my live website folder)
/home/jon/code (a private folder not accessible from the web to store my source code)

I SSH to the server and run:

cd public_html
git clone /home/jon/code/drupaltest.git drupaltest

If your repository is on github or on another server you will need to adjust the “/home/jon/code/drupaltest.git” path in the command above.

Then I:

cd drupaltest
ls

I see all my files listed. Now I browse to my website http://www.saintsjd.com/drupaltest/ and run the drupal installer.

With a working site at http://www.saintsjd.com/drupaltest/ we are ready to begin making our changes to the website and deploying the changes to the live site using git. The steps that follow are the steps you will repeat for each new feature that you want to add to your website.

Deploying using git

There are many automated ways of deploying code using git. I recommend Fabric and Heroku for Rails apps. I will show only one basic manual deployment method here.

Our workflow will be:

1. Develop and test a new features for our website on our local development box
2. Commit and push the new code to the repository
3. Pull the tested code from the repository to the live website

We repeat this workflow each time we add a new feature to our website.

Lets say I want to add the pathauto module to my drupaltest website. I download the module from http://drupal.org/project/pathauto and the token module http://drupal.org/project/token, unzip, and copy the modules to my sites/all/modules folder on my local development machine.

I browse to http://localhost/jon/drupaltest/#overlay=%3Fq%3Dadmin%252Fmodules and enable the module. I configure it and test that it actually works.

Once I am happy that the module works well. I use git to commit the new code to my repository.

git add . (stages our new code)
git commit -m “adding pathauto module” (commit our new code to the local repo)
git push origin master (send the code to our origin repo on the server via ssh)

I can then SSH to my live server and cd into the public_html/drupaltest/ folder. Synchronizing my new code changes is as easy as:

git pull

After I pull in the new code I need to enable and configure the module on the live site going to:

http://www.saintsjd.com/drupaltest/#overlay=admin/modules

Repeat the steps in the “Deploying with git” section each time you want to add a new feature to your website.

Important! Protect your .git folder on the live website using .htaccess

I don’t really want others reading my git repository on my live site by browsing to http://saintsjd.com/drupaltest/.git. I prevent this by running:

chmod -R og-rx /home/public_html/drupaltest/.git

I also add a .htaccess file to the .git folder containing:

Deny from all

I enjoyed the movie and I highly recommend you watch it. The only challenge in watching is wondering what you can possibly eat afterwards. And so, I present to you a solution… how to watch Food Inc. without loosing your appetite:

1. Appetizer: start with a taste of Food Rules: an Eater’s Manual by Michael Pollan
2. Main Course: watch a healthy portion of Food Inc.
3. Dessert: finish everything off with videos from www.ted.com: “How I Fell in Love with a Fish” and ”Why I am a Weekday Vegetarian“

Food Inc. offers a great website with positive steps you can take. The two Ted videos above will leave you inspired and hungry.

To accomplish this and keep all of my URLs working properly I used Apache mod_rewrite

Options +FollowSymLinks
RewriteEngine on
RewriteCond %{HTTP_HOST} ^([^.:]+\.)*ituprising\.com\.?(:[0-9]*)?$ [NC]
RewriteRule ^(.*)$ http://www.saintsjd.com/$1 [R=301,L]

In an effort to get over my food industry learning curve, I went Naturally Boulder Spring Fling. Well worth it.

Some of the titans of the organic food industry were there: Rudy’s Organic Bakery, White Wave foods, and Micheal Funk of UNFI. All where very willing to chat. I just mentioned that I have this trail mix thing going in my kitchen and that I was looking to get advice on where to take it next. Everyone seemed to have advice and everyone offered to put me in touch with a friend who could help me get started.

Sweet. Boulder is the best place to start a business. This community loves entrepreneurs.

The take aways:

1. Next buzz word is GMO. Most companies are asking their suppliers to avoid using them. Consumers are starting to become aware of GMO and look for products without it.
2. BPA. BPA leaches into food from plastic containers and is closely linked to high rates of cancer. We need to look for BPA-free packaging
3. Its best to price organic suppliers into your business model from the beginning.
4. Ship by train or rail for lowest carbon emissions. Truck is 12 times more emissions. Air is 85 times more emissions.
5. Drive an ugly truck. Advice: as a boss, always drive the ugliest car in the parking lot so employees do not ask for raises hilarious. I got this one covered. Marissa often refers to my truck as the “eyesore”.

Siddhartha by Herman Hess
Every time I read this book I feel inspired and love it.  ”What other path was there?”

Thousand Splendid Suns by Khaled Hosseini
Wonderfully written characters immerse you in the recent history of Afghanistan.

The 4 Hour Work Week by Timothy Ferris
As an entrepreneur, make it your goal to decrease the amount of time you need to run your business. If you start working 12 hour days make it the point of your business to find efficiencies and ways to do the same in 4 hours. Its a great mentality that can lead to profitability, new ideas, and a healthy life style.

Born to Run by Christopher McDougall
The more I think about this book, the more I see running as a metaphor for life. We are endurance animals meant to persistently peruse solutions to our problems wearing them down not with bursts of sped or luck but with persistence and presence over time.

I love when the book talks about building endurance… getting to know the Beast (fatigue). Fatigue is not something you can beat in one training run or out sprint or out luck. As you train for endurance races, each time, its  a chance to get to know the Beast to spend a little bit long time in its presence to wear it down just a little bit and build up your tolerance/comfort to it. So many things in life are endurance races.

The final thought from the book: “We do not get old because we run. We get old because we stop running” Find ways… any way… to stay patiently and persistently active.

Rework by Jason Fried
The best summary of this wonderful take on business is a review in the introduction: “This book’s assumption is that an organization is like a piece of software. Editable. Malleable. Sharable. Fault-tolerant.” Businesses, the smart ones, stay nimble and simple. Organizations have versions and features and milestones. When I stumbled into business, the only proven way I knew to build things was following the software development model. I have said, though not as clearly as this book, that the principles of good software development often apply to good business development. Release early and often. Create and Celebrate bite-sized milestones. Under do the competition. Planning is Guessing. Half but not Half Assed. This book presents an eloquent philosophy for business.

Next on the reading list is Food Rules: An Eater’s Manual by Michael Pollan.

The answer: Sooner than you might think.

Both sites make it really easy and fun to sell online.

Etsy is the way to start off if you are selling hand made goods for sure.  On Etsy its easy for buyers to wander from seller to seller looking for products.  They can easily leave your store for another vendor, but as we have found, this community of wandering buyers have also provided us with many sales. Etsy also promotes your products to their homepage, providing valuable exposure for your products.

Shopify offers more customization and personalization of your store. Stores are not connected so buyers cannot directly wander to other stores. Shopify does not provide any built in promotion of your products either. They provide a simple, beautiful store front for your products that you must promote yourself.

Because Etsy provides such good exposure for our products we will never fully abandon Etsy. But now that we are growing and able to do more of the promotion ourselves, Shopify becomes a sensible option for our small business ecommerce needs. Only consider Shopify over Etsy if you fell your business has the momentum to promote its online store on its own. Once you do find that momentum, at what point will switching actually start saving you $?

Well, Etsy charges $0.20 to list a products and takes 3.5% of each transaction. Shopify charges $24 per month for their basic plan and takes 2.0% of each sale. Using this data, at $1600 is sales per month, Shopify becomes the cheaper option.

As sales continue to grow, you’ll want to upgrade to Shopify’s $59/month plan when you reach $3500 in monthly sales.

The first upgrade failed. With errors in the Connect console. I found that I needed to disable the Blank theme. I switched to the default theme and removed the Blank theme using Magento Connect. After that upgrade proceeded without error… almost.

When I logged back into admin after the upgrade I experienced a common problem many other users have had. I saw only the Dashboard and the System menus in the admin section. Fortunately, http://www.magentocommerce.com/boards/viewreply/216653/ helped me solve the problem. After that, I could see all the links in Admin.

Next, an error appeared, saying that indexes where out of date. Clicking the link, I was able to update indexes without trouble.

Next I tried to enable my old custom theme for magento 1.3. The file structure of the new themes were just too different. And I notice that Magento Connect had not copied in all the new theme files compared to a fresh install of 1.4. So, back to square one I went:

1. Switched to the Default Default theme
2. Disable cache
3. Backed up everything!
4. http://www.magentocommerce.com/boards/viewthread/79499/
5. Update product indexes System -> Index management

At this point all the store data seemed to be working properly. From what I read in the forum, its best to re-create your old custom theme from scratch. So I did:

1. Create folder /skin/frontend/myPackage/default
2. Create folder /app/design/frontend/myPackage/default
3. Copy /app/design/frontend/default/blank/etc and /app/design/frontend/default/blank/locale to /app/design/frontend/myPackage/default
4. Copy /skin/frontend/default/blank/css and /skin/frontend/default/blank/images and skin/frontend/default/blank/favicon.ico to /skin/frontend/myPackage/default
5. Enable my theme and test /admin/system_config/edit/section/design/
6. From there I slowly copied in the CSS and images from the theme I had designed from magento 1.3

Upgrading Magento to 1.4 was painful and time consuming even with all the help of the poor souls who had crashed their sites before me. That said, using magento still seems to be faster and less time consuming that building my own ecommerce solution from scratch. Given the time it takes to make Magento  perform well and maintain its updates, Shopify’s pricing does look more attractive and reasonable.

The widely held view is that running, over-time, is damaging to your body. It is simply too much impact. In my injury free years I never believed this… I never wanted to. But, this injury had me down and thinking like everyone else. I love how running makes me feel… the reflective clarity of long runs… the invigorating endurance that builds and runs through your body the next day. But every where I turn, those that love running as much as I do are finding it harder and harder because of the constant string injuries they have to battle.

A friend of mine had recently experienced the same melancholy of injury. He gave me the book Born to Run by Christopher McDougall and told me it would change my running life. The author starts by asking the question of why running is “bad for us”. Through the story of the Tarahumara (a tribe known for its incredible distance runners), sports page commentary of elite ultra marathon racers, and interesting overview of cutting edge evolutionary biology on running, McDougall finds compelling evidence that its not running that is bad for us… its how we run that is.

In fact, we as a species evolved and were born to run long distances more than any other. This news was inspiring to me. We have neck muscles that only running species have, we can breath out of stride unlike any other mammal, and our feet (according to Da Vinci) are master pieces of engineering and efficiency.

How do we go about running incorrectly as cause injury? First, and most importantly somewhere along the way we stopped running for the joy of running. When we run for other reasons: $, or to loose weight, we increase in the number of injuries we expirence. There is compelling anecdotal evidence of this, but its hard to prove scientifically.

In my case this is exactly what happened. About one year into my return to running, it was not longer about peaceful reflection and just the joy of feeling healthy. I was gunning for time. I do believe this gunning type of training was not as effective. My times were not improving as fast as when I was running for joy. It took more work… more pain to get where I wanted to be. I also started to find more strange and nagging injuries popping up. This latest IT Band injury being the worst.

A second way we injury ourselves running is by using fancy equipment that weakens the natural ability of our foot to adsorb shock. About six months ago I went on a run with a group of friends who were wearing Vibram FiveFinger barefoot running shoes. I remember being amazed at the time by the way running barefoot immediately improved the form of my friends who were not regular runners. Without trying, they where running with backs straight, upright, with quick strides. They looked like elegant pros. They looked like I have been trying to teach my self to run for well over a year. By not being able to slam their heals into the ground, even the causal runners who never have been taught what good form is, naturally and instinctively fell into the efficient running form.

Seems like we are Born to Run. I thank my friend for passing along the book. McDougall tone and style is not one that I enjoy, but he has written a valuable and inspiring book. When I do return to the trails it will be for one purpose… the joy of running and none other. I also plan on slowing building up to barefoot runs. I can’t wait to see just how far my perfectly evolved feet can go pain free.

This blog provided an excellent solution to the problem:

http://www.economyofeffort.com/2009/10/upgrade-to-karmic-eclipseaptana-u…