https://github.com/krumberg/astar

https://github.com/krumberg/podcastfs

• Reference counting
• “toString” Java-like method in base type RObject
• “hashCode” Java-like method in base type RObject
• Properties

https://github.com/krumberg/robject

Note that you need my Google Test-like unit testing library “rtest” to build the code.

The speaker is the author of Gollum, the wiki system used by Github. I tried it yesterday and it’s really easy to setup and seems to work very well.

To get gollum running, open a terminal and execute

gem install gollum
git init
gollum


This will install gollum, create a new git repository (preferably in a new and empty folder but I wanted to keep the example short) and starts a wiki webserver on port 4567 that is reading/writing to this repository.

Fork a branch, do some development and merge it back to master.

Assume you have written some code that should be developed further in another branch, or assume you are going are to begin writing such code.

Fork the current branch
git checkout -b mynewfeature

Do some hacking – commit, commit commit. You should know how this works.

Now you want to merge it back to master.
git checkout master
git pull --rebase . mynewfeature

‘git merge mynewfeature’ should be enough but you may have done some work in your local master and forgot to push it. In such case we get a merge which is a quite ugly compared to a rebase since we then get a nonlinear history.

Now your local master has your new code and it’s safe to delete mynewfeature
git branch -d mynewfeature

Rebase from the server and push the code to the server.
git pull --rebase # You may have to add ‘origin master’ here if your tracking config is missing
git push

Split a large commit into smaller commits before pushing

Assume that you have made a large commit that you
must split before you push it to the server.

Undo the commit
git reset --soft HEAD^1

Now all of your commit are in the index. Move them back to the unstaged area.
git reset

(1)

Now issue a git status and check what your commit contains
git status

Start adding parts using the -p flag. Answer ‘y’ or ‘n’ depending on whether the chunk should be added or not
git add -p # You may add a folder or file path here

Look at what’s in the index
git diff --cached # I have an alias 'git dc' for this

Once happy with your index, make a commit of it
git commit -m “A tiny feature”

Go back to (1) until there is nothing more to add. Then merge the branch back to master according to the previous workflow description.

Still losing all your music or your video collection is a horrible experience but here comes git-annex to the rescue. It allows you to manage your files from a single location, you can add new files, remove files, rename or move files and then propagate these changes to multiple disks or servers.

Many people don’t do backups at all. Some do but not regularly. Some do them regularly but they never try to restore their data. Just assuming that your backup system works in the reverse direction is naive and dangerous, but it’s all too common. If you use a distributed version control system the problem goes away. Every client then has a full backup of all your data. In the case of git-annex this is not necessarily the case but it allows you to configure a policy that forces you to store file X in at least Y different repositories.

Finally I use Time Machine too as it allows me to very quickly get back on track if I need to reinstall my complete system. For the moment Time Machine is also responsible for my photos and my music. If you don’t use a Mac then checkout rsnapshot or DeltaCopy. If you find these systems hard to use you can store your data in the cloud using Dropbox (2 GB free) or Box.net. Use the right tool for the right job!

If you lose all your family photos there is no one else who can help you get those memories back. Start doing backups!

For people using GNU/Linux or for Mac users who desire a bit more control it’s possible to simulate almost all of Time Machines features (except for the nice GUI) using rsync. I have written such a script and I might just as well share it. Please give feedback if you have any suggestions for how to improve it. As usually you have to tweak it to match your folder structure. Please note that I do not take any legal responsibility regarding how it’s used or what it may do to your data. I just believe it works!

If you use Microsoft Windows then checkout DeltaCopy which is a popular front end to rsync.

Update:
The script below is a quick and simple hack but it seems to work just fine. A more complete and mature solution for *NIX that is also based on rsync and hard links is rsnapshot.

#!/bin/bash

dirs2back=(~/Music ~/Documents)
destdirs=(/Volumes/media)

function back {
BDIR=$1

if [ -d $BDIR ]
then
	foofile="$BDIR/foofile"
	if touch "$foofile"
	then
		echo $BDIR is writable

		if ln $foofile ${foofile}_lnk
		then
			rm ${foofile}_lnk
			rm "$foofile"
		else
			echo "Error: Sorry this filesystem does not support hard linking"
			rm "$foofile"
			exit
		fi

		RDIR=$BDIR/rsyncmachine
			
		TODAY=`date | awk '{print $4 "_" $3 "_" $5}' | sed s/://g` 
		TODAY=$RDIR/$TODAY
		echo $TODAY
	
		LASTTXT=$RDIR/last.txt

		if [ -d $RDIR ]; then
			echo "Running incremential backup"

			if [ -e $LASTTXT ]; then
				echo "Performing incremential backup"
				YESTERDAY=`cat $LASTTXT`
				echo $YESTERDAY

				if [ -d $YESTERDAY ]; then
					for item in ${dirs2back[*]}
					do
						rsync --progress -av --include=".*" --link-dest $YESTERDAY $item "$TODAY"
					done

					echo $TODAY > $LASTTXT
				else
					echo "Error: $YESTERDAY is not a directory"
					exit
				fi
			else
				echo "Error: No last backup, please update last.txt manually!"
			fi
		else
			echo "First time running rsyncmachine"
			echo $TODAY

			mkdir -p $TODAY

			for item in ${dirs2back[*]}
			do
				rsync --progress -av --include=".*" $item "$TODAY"
			done

			echo $TODAY > $LASTTXT
		fi

	else
		echo "$2 is not writable, not syncing"
	fi

else
	echo "Error: $BDIR is not connected"
fi
}

for item in ${destdirs[*]}
do
	back $item
done

You may notice that I run “git add scripts” instead of “git annex add scripts” since this folder contain small files that I want to keep under version control.

Disclaimer: It’s not written in the most efficient way possible but works well for me. However please give comments if you think I’m doing something really silly.

Updated: New version with improved but not perfect error handling


#!/bin/sh

# Drop all movies on laptop
cd $laptop
git annex drop Video


I wrote at a time when I was using GNU Emacs to a larger degree than what should be regarded as healthy. Emacs can be used for almost everything including audio playback. Emms is a music player within the editor and it can handle playlists and browse directories but no does not support podcasts. podcastfs closes this gap.

I have not touched the code for two years and these days I use Google Reader for reading blogs and podcast listening.

Podcastfs works well but is lacking some important features. It does not support refreshing a podcast and it’s not possible to add or remove a podcasts on the fly. You have to umount and mount the whole filesystem to perform any such action.

Nevertheless the code should still work and is very open for any hacker with too much spare time. It’s written in GNU C using GLib and it’s licensed under the MIT license. Please fork it and send me a pull request if you do

git://repo.or.cz/podcastfs.git

git-annex provide a few very nice features including

• The ability to handle trees of large files. “Normal git” is not an alternative is this case.
• Automatic data retrieval. Any client can see the whole repository of files (as symbolic links) although it does not necessarily have access to any of them.  The user can run a command such as “git annex get movie.avi” and git-annex will download this file from any remote that has it.
• Safe data dropping. Any client may “drop” a file at any time. This means that it’s removed from the local data storage but this will only be allowed if git-annex can verify that it exists at some remote. It’s possible to configure this policy. For example you may decide that some very important files must always be stored in at least three places.
• Rename tracking. If you rename or move a file this change will be tracked by git and affect other repositories when you choose to perform a push or pull. One very cool thing is that you can rename and move around files you don’t even have available from your local machine. Again this is possible since git-annex only tracks symbolic links in addition to tracking which files are available where. Before I found git-annex I used rsync but it’s not clever when it comes to renaming. However rsync is used “under the hood” when files are transferred between git-annex repositories.

So this sound great. But what is the catch?

• To make sure that no data is lost by accident all files are kept read only and you must unlock and lock files to modify them. This is very uncommon when it comes to movies or executable files but is often needed when handling music files and images.
• Git-annex gets quite slow if you add TOO many files. I’m talking about a couple of hundred thousand files. I don’t have that many movies or music files but iTunes and iPhoto love to create billions of billions of tiny files so don’t store their folders in git-annex! Trust me I have tried
• Some programs don’t like symbolic links, they want to access real files. Unfortunately this includes my Boxee media player. This may require you to lock and unlock your whole library quite often which is a waste of time.

I use git-annex to handle my movie collection and executable files such as application or operating system installers.

The git-annex project is developed by Joey Hess and it’s very active. Joey makes updates almost every day and if you find a bug and report it on his webpage he will solve it within a day or two. This guy is marvelous!

Currently git-annex does not have a GUI. One has to type commands in a terminal and this makes it less usable for normal users. I think this may change as git-annex continues to mature and gain popularity. We all, including average people need a good distributed system for managing our large collection of files and I believe that git-annex is up for at least a part of the task.

If you want to try git-annex and use Linux or Mac OS X then go to

http://git-annex.branchable.com/

Update:
I have “solved” my Boxee issue by running rsync between a git annex repository and the filesystem on my boxee like this

rsync --size-only -vaL --progress --delete $GIT_ANNEX_REPO $BOXEE_FS_PATH

Instead of copying the symbolic links it copies the data referred to by these while still naming the files according to the symbolic links. Works great apart from when I do massive renames or move folders around using git-annex. Then all these files and directories have to be transferred again.