Git with SVN by Praveen MV

Introduction
For the uninitiated, Git was invented by Linus Torvalds to support the development of the Linux Kernel, but it has since proven valuable to a wide range of projects. There are two git packages for windows: Cygwin based git and msysGit.

Git concepts

Repository: An archive of what the working tree looked like at different times in the past — whether on your machine or someone else’s. It’s a history of snapshots, and allows you to compare your working tree to those past states.

The index: Git does not commit changes directly from the working tree into the repository. Instead, changes are first registered in something called the index. Think of it as a way of “confirming” your changes, one by one, before doing a commit (which records all your approved changes at once).

Working tree: Any directory on your file system which has a repository associated with it (typically indicated by the presence of a sub-directory within it named .git.). It includes all the files and sub-directories in that directory.

Branch: Just a name for a commit, also called a reference. It’s the parentage of a commit which defines its history, and thus the typical notion of a “branch of development”.

Master: The mainline of development in most repositories is done on a branch called “master”. Although this is a typical default, it is in no way special.

HEAD: HEAD refers to the most recent commit of the last branch you checked out. Thus, if you are currently on the master branch, the words master and HEAD would be equivalent.

Getting started

Lets start of by seeing how we can checkout exisiting repository , make modifications and check in .Checking out repository is as simple as :

git svn clone
This might take a long time based on how old the codebase is . It gets information of every thing that happened on the repository , all the logs etc .
However the simplest and fastest way to check out exisiting repository is to copy .git folder from any one who has code checked out. Using git bash, navigate to folder containing .git folder and execute the following command

git checkout
Now we are ready with our local repository .
Next as developers we modify the code, add new feature . Now we need to commit . So lets see how to commit a code . Use the following comand to view the modification made to the source code.
This comand shows all the new and modified files .

git status
Now we need to add all the new and modified files to list of files to be committed . Use the following:

git add .
We can also add one file at a time using

git add filename
Now we must commit the file added to our local repository

git commit -m "Message while commiting"
So far we have commited to our local repository . Now we must take updates from the main repository to see if there are any modification or confilicts .

git svn rebase
This gets the latest files from the repository and updates the modification made by you on to the latest file .Assuming there are no confilicts. Now we can commit our code to the central repository .
so we run

git svn –dcommit
We are done with our first commit .We have covered the basic flow of git .

Do high-performing teams always need retrospectives?

by Sumeet Moghe

A few months back Patrick Kua wrote a blog conjecturing if the lack of retrospectives is really a smell. Pat mentioned how he was very lucky that the team had some really strong people who got things done and kept the project 'continuously improving'. To quote Patrick, “It’s amazing what a bunch of energized, passionate and people with the “solve the right problem once” attitude can achieve."

Reminiscing this post from Pat, I had a few thoughts. Given us agree that:
• retrospectives are a 'best practice';
• and that they are a tool for improvement;

Is it fair for us to say (at least theoretically) that we can take this 'best practice' to an extreme level just as rationale behind extreme programming may suggest?
• Second, Agile methods (at least theoretically) assume a team composed of the 'best people' who are 'generalizing specialists' or 'versatilists'.
• The key to having a really strong team could then be mechanisms that not only encourage strong communication, but also those that allow teams to recognize problems, find solutions. That then will fuel continuous improvement, perhaps making retrospectives purely an optional ritual.

What could these mechanisms be?
• My passion for retrospectives set aside, I realize that the practice is definitely more than a decade old in the mainstream. Things have changed significantly since then.
• More teams understand the value of solving problems 'just in time';
• Command and control leadership may have not disappeared from the horizon, but leaders are slowly discovering their roles in empowering their teams to take more control of situations and problems.
• Technology is changing fast and our ability to use tools to make problems visible solve them is fast increasing.
• Here are a few ideas I had to increase communication and to recognize and solve problems on a team. These ideas don't necessarily negate the requirement of a retrospective, but they can perhaps take us one step further to being high performing teams.

A low tech method - daily 'hot topics'

A few months back, we were a team of 7 people with Ritin Tandon at the helm as the team lead. Ritin devised a method for us to recognize issues and solve them on an ongoing basis. In the team area, Ritin put up a flip chart called "Hot Topics". Every time anyone in the team had something to discuss or a non-urgent problem to solve, they'd put up a sticky on the flipchart. At the end of the day, one of us (often Ritin) would facilitate a quick discussion around our hot topics and we'd volunteer to solve the problems then and there. If we expected that a problem would take time to solve, then one or more of us would sign up to work on it and we kept reporting back progress to the team. It has been a fantastic practice and for the investment of a few minutes each day, we got a huge sense of fulfillment by taking blockers out of our way. What we were doing was a bit of a mini-retrospective each day and that helped us be a continuously improving team.

A hi-tech method - use Web 2.0 tools to surface and resolve problems.

There are quite a few tools these days that can help create high quality communication in teams. Two tools that I think can be really useful to surface and resolve problems in a team are Google Wave and Google Moderator. And of course there’s the indigenous www.ideaboardz.com.

Google Wave
Google Wave follows the paradigm of blips. It could be quite easy to create retrospective playground on Google Wave where you create brainstorming blips (Keep Doing, Stop Doing, etc) on the wave and people can add their thoughts and following discussion under those blips. In fact I think this could be even better than a ritual retrospective where we often don't discuss issues because of a lack of time. Using this method, people can actually choose to comment on every issue they feel passionately about instead of restraining themselves only because others don't see the value in their thoughts yet!

Google Moderator
Google Moderator is a great social application to crowd source ideas. You could potentially ask your team an open ended question about ideas for improving the project. As the team posts it ideas, members can vote up the ideas they like the most and provide commentary on its implementation. Over time, you have a nice prioritized list of improvement activities for your project. As you implement these ideas, the burning need for a retrospective may disappear.