Today I had to merge changes from one repository into another. Let’s assume you want to merge beta into alpha.

Operations are performed in repo alpha:

git remote add beta_repo
git fetch beta_repo
git merge beta_repo/master

In this case, beta_repo is the name you pick for remote.

If you just need to cherry-pick a certain commit from beta you can omit the last step and replace it with the cherry-pick.

More on the topic of remotes:

To encrypt and decrypt files in Linux there is a utility called gpg (Gnu Privacy Guard). This is a short GPG tutorial.

Quick usage example

gpg -c foo.txt

It will prompt you for the passphrase and a confirmation. Now you will have the encrypted foo.txt.gpg file. To decrypt a file:

gpg -d foo.txt.gpg

This will forward the output to the console. You can output it into a file:

gpg -d foo.txt.gpg > foo.txt

GPG keyring

This is all secure, but not quite enough if you are paranoid. Keys are what makes gpg great. Let’s generate a private key:

gpg --gen-key

And create an ASCII version of a public key:

gpg --armor --export "John Doe" --output johndoe.txt

Public key johndoe.txt can be freely distributed. Now you can encrypt files for yourself only:

gpg -e -r "John Doe" foo.txt

Now if you decrypt a file it will require the passphrase you specified while generating a key. To encrypt a file for someone else you should have this person’s public key.

Let’s assume Stan Smith sent you a key, stansmith.txt. You import it using:

gpg --import stansmith.txt

And encrypt the file:

gpg -e -r "Stan Smith" foo.txt

I had some issues with the strtok function. Here’s a detailed explanation and usage for it.

The strtok function is used to tokenize a string and thus separates it into multiple strings divided by a delimiter.

#include <stdio.h>
#include <string.h>

int main() {
    int j, i = 0;
    char delim[4];
    char user_input[81], *token[80];
    user_input[0] = 0;  // set first byte to 0 to detect empty string

    // validate the string length
    while (strlen(user_input) <= 1 || strlen(user_input) > 82) {
        printf("Feed me a string to tokenize: ");
        fgets(user_input, sizeof(user_input), stdin);

    printf("And a delimiter (up to 4 chars): ");
    fgets(delim, sizeof(delim), stdin);

    token[0] = strtok(user_input, delim);  // first call returns pointer
                                           // to first part of user_input
                                           // separated by delim
    while (token[i] != NULL) {
        token[i] = strtok(NULL, delim);  // every call with NULL uses
                                         // saved user_input value and
                                         // returns next substring

    for (j=0; j<=i-1; j++) {
        printf("%sn", token[j]);

    return 0;

Let’s compile and execute it:

Feed me a string to tokenize: foo/bar/baz
And a delimiter: /

The first call to strtok returns the pointer to the first substring. All the next calls with the first argument being NULL use the string passed at the first call and return the next substring. The function returns NULL if no more substrings are available.

A reminder on how to initialize a fresh gitolite repository, assuming that gitolite has already been set up.

All actions are performed on a local machine. In this case: ~/gitolite-admin is admin repository, ~/foo is desired repository, is gitolite hostname. Command vi stands for the text editor, but you may use whichever editor you prefer.

cd ~/gitolite-admin
vi conf/gitolite.conf

Add lines (obviously you may want to use individual users instead of @all):

repo foo
    RW+ = @all

Save it. Next:

git add conf/gitolite.conf
git commit -m "Add foo repo for @all"
git pull --rebase &amp;&amp; git push
mkdir ~/foo
cd ~/foo
git init
git remote add origin

Add some files at this point. In this example, only .gitkeep is added.

git add .gitkeep
git commit -m "Initialize repo"
git push origin master

The new repository is all set up now.

A quick note on how to set up GUI difftool to use with git on Windows (Git Bash, Cygwin, etc…).

Download and install GUI diff tool of your choice, get the path to executable.

Create in directory included in your path (for example C:\Users\{username}\bin in Git Bash). Let’s take SourceGear’s DiffMerge as an example.

"C:/Program Files/SourceGear/Common/DiffMerge/sgdm.exe" "$1" "$2" | cat

And in your ~/.gitconfig:

    tool = diffmerge
[difftool "diffmerge"] "$LOCAL" "$REMOTE"

And difftool is available via git difftool command now.