Book Review: Pragmatic Version Control Using Git

I have not posted a lot on this blog recently so I thought I would add a quick book review. I recently (about a fortnight ago) finished Pragmatic Version Control Using Git by Travis Swicegood, published by the Pragmatic Programmers / Pragmatic Bookshelf.


I come from a Subversion background. In fact, only recently I think I really started to hit my stride with the version control system. But as sometimes happens I was late to the party. An upstart version control system named Git, first popularized as the new version control system for the Linux kernel, is becoming increasingly popular. A key difference between Git and Subversion is that Git is a distributed version control system control. A git repository is designed to be cloned, changes are pulled between repositories and at anyone time multiple developers may be working on their own individual, complete copies of the repositories before refining their commit history and pooling their changes.

So although Git uses many of the same principles I am used to in Subversion, such as branches and tags, it is a fundamentally a different approach to source control, and requires a good book to explain it.

Travis Swicegood's Pragmatic Version Control Using Git has a lot in common with the previously released Pragmatic Version Control Using Subversion. Physically it is exactly the same dimensions in length and breadth and at 224 pages is about 30 pages longer. The pages are thick, high quality acid-free and mostly recycled paper. The print is grey scale and each chapter has a few diagrams or screenshots, but an average of ten or so plain command and output listings.

The first chapter in the book talks about the basic of what version control is and what some of the terminology means. Chapter two talks about how to get Git installed on your system and some configuration you might need to do. Chapter three sets up an example project has a brief overview of all the common actions, like adding files, committing them and creating a release branch. The detail is light, since the topics are covered in later chapters of the book.

Chapters four through nine delves into the details of the common operations you are likely to use in Git: Adding and committing files, using branches, examining the log, working with remote repositories, organisation and repository administration. The focus is on building on the knowledge form chapter three and exploring useful commands and when they might be useful.

Chapters ten and eleven cover migration to Git from other source control versions and you can set up a Git server.

As in Pragmatic Version Control using Subversion, there is a very useful Command Summary and Recipies section as one of the appendices. Long after you have finished the book you might find yourself returning there to get a quick refresher on the keystrokes required for different Git commands you may not commonly use, such as Rebasing.

The book is written in a very conversational style and is consequently very easy to read. There are couple of areas (for example, during the chapter about rebasing) where more detail and discussion would have been helpful in avoiding confusion.

In comparison to the Pragmatic Version Control with Subversion book, less time is spent discussing conventions of use. This may in part be because Git codifies some of the conventions of Subversion - for example tags and branching - into actual functionality. It would have been nice however to cover in more depth some of the other issues of convention that arise from having a distributed source control system. 

The examples in the book are easy to follow, but they are also a bit simplistic. Each chapter starts with instructions on how to clone the repository required for that chapter from the author's Git hosting site.

Overall I rate the book highly for newcomers committed to using Git. Readers already familiar with Subversion will breeze through the book. Those that are completely new to source control may struggle. Was it worth buying for me? Yes.

Let me know if you have any further questions about the book in the comment area.

Book Review: Programming Collective Intelligence : Building Smart Web 2.0 Applications

Programming Collective Intelligence: Building Smart Web 2.0 Applications
By Toby Segaran
O'Reilly 2007
ISBN 978-0-596-52932-1

I bought and read Programming Collective Intelligence about a year ago and it remains one of my favourite books.


According to the author, Collective Intelligence is the "combining of behavior, preferences, or ideas of a group of people to create novel insights." This is a book about approaches and algorithms that allow you to do more with datasets of user-generated or contributed content.

The Book takes a task-based approach. After an introductory chapter the book is divided into chapters around a performing a specific sort of analysis. You'll find chapters on making recommendations, discovering groups, searching and ranking linked content (like Google's Pagerank), optimisation, document filtering, modelling with decision trees, price models, classification and genetic programming.

You will not find heavy theoretical discourse in this book. As required the book introduced new underlying algorithms but only in the context of the current task. Those with a background in the material might benefit from knowing that the following algorithms are covered: Bayesian classifiers, decision tree classifiers, neural networks, support vector machines, k-nearest neighbours, clustering, multi-dimensional scaling and non-negative matrix factorisation.

The book is black and white and is 334 pages long with a mid-sized typeface. The writing style is relaxed and conversational, but you will need to concentrate at times to follow the concepts being explained. Each chapter has many code samples and quite few data tables and diagrams. The net effect is that where text, code or diagrams are hard to fully grasp, the other code, text or diagrams can clarify the meaning and intent.

The code samples are written in Python in a tutorial, incremental style, so you can follow along with the text. You will need download and install some well-known third party libraries to recreate most of the examples, and many of the samples either require an internet connection to supply the data or use data sourced from the internet.

A very short Python primer is included in the preface. Knowing Python is not a pre-requisite to reading and understanding the code samples, however - I did not know Python at all when I read it and still managed to follow along. As someone who is now learning Python I can appreciate that the code samples are all very concise and polished, even if the powerful use of list comprehensions sometimes confused me at the time I read it.

I enjoyed this book immensely and it remains one of my favourites. I had only very limited exposure to the concepts prior to reading the book, but I found myself increasingly excited about the possibilities as I read. Even as I page through the book for the purposes of refreshing my memory it is impossible not to earmark certain sections for my current projects.

Who should read the book? I think non-programmers would struggle getting through the book, and readers wanting a more theoretical and deep understanding of the algorithms may be disappointed. Programmers with a background in any language will probably extract a lot of value from the book, however, especially if these concepts are new to the them. For that audience I strongly recommend this book. Unlike many other technical books I think this book will remain relevant and useful for quite a while.

Programming Collective Intelligence : Building Smart Web 2.0 Applications is available from Amazon, Oreilly.com and possibly your local technical bookstore.

(Full disclosure: As an Amazon associate, I will get paid if you purchase this book though the links to Amazon on this page. Use this Amazon link if you do not wish this to happen. Was the review helpful?)

Book Review: Using Google App Engine

Using Google App Engine
By Charles Severance
Published by O'Reilly in May 2009
ISBN: 978-0-596-80069-7

Recently I have been working on a project hosted on Google App Engine. Not coming from a Python background, and not knowing a lot about the feature of the Google App Engine, I was keen to find a book on Google App Engine (using Python) that I could use to thread a narrative through the sometimes dry API references available from Google. I bought Using Google App Engine a couple of months ago.

The first thing I noticed about the book was its physical dimensions. At 241 pages using a largish typeface it seems like a small book. You will not break your back bring it home. The book is in black and white and there are a few code listings in each chapter. A few diagrams are in the book as well.

The book is written in a relaxed, approachable style that is very easy to read. It definitely not desktop reference or How-To manual. Rather, across the course of the book the author takes you through the process of a building a new application that lets you log in (and that is about it).

The book starts off with a Chapter on what Google App Engine is and why it exists. Following chapters explain HTTP, HTML, CSS, HTML forms, Python, the Webapp framework templates, cookies and sessions, the datastore, AJAX, Google Application administration and the memory cache. Java on Google App Engine is not covered.

It is a fair comment that most topics get little attention apart from a description, the new changes to the example application and enough about the topic at hand to explain the example . only. Together the amount of knowledge provided by the book represents a very think taster of each of the technologies discussed. You will not find a list of the available tags in the HTML section, for example, any sort of close discussion about the syntax of javascript or for that matter an understanding of most of the services provided in the Google App Engine platform.

The feel of the book is of an extended tutorial. The example, once complete, is of a similiar complexity to the application built in the Google Getting Started tutorial for Python.

This book appears aimed at the developer who needs to get to speed in google app engine and more broadly web applications quickly. At the end of the book the reader will at least have a basic understanding of the topics covered, but to transition this understanding to developing real applications will take a lot of effort.

This book does offer a nice end-to-end description of the technologies involved that make web applications possible.

For myself I most enjoyed the initial chapter on Google App Engine and later chapters on sessions and the use of the Memcache. It is worth mentioning that the author uses what might be a custom sessions library in his example which was to be available on the internet. I could not find it, however. This is something that might be a real problem for a beginning following alone on their own computer and Google App Engine account.

Overall I would judge the book to be a workable extension or supplement to the google getting started tutorial. Developers new to the world of web applications have the most to gain from reading this book, but they will still need a lot of other material to become competent. Experienced web developers will not have much of use of the first half of the book that discusses web technologies, and experienced python web programmers who have already gone through the Google tutorial will perhaps only find the discussion on Sessions interesting.

None of the knowledge or techniques shown in the book are not available online, so in that sense the book is a luxury rather than a necessity.

Let me know if there is anything else about the book you would like to know, and I will do my best to answer.

You can buy Using Google App Engine online at Amazon
, Oreilly or if you are lucky, your local technical bookstore.

(Full disclosure: As an Amazon Associate, I receive payment if you buy this book using the Amazon link above.)