Experiments at work

Back after a while with another git magic. We already have seen how to get rid of the top most commit in this article ->  Git magic - Make commits disappear First of all, it's one of the not so recommended way of doing it and more than that, it can only get rid of sequential commits from latest. I recently happened to get into a scenario where I had to drop a commit in the history by keeping the latest ones. As part of that exploration, presenting you this article. /**  *  @disclaimer  * Please read this post fully before executing any command. My scenario might not be same as yours. */ To my greatest surprise, I didn't know a git rebase could do this. Please continue to read to know how. The steps are simple, Count until the commit line you need to drop using git log Do an interactive rebase and you're done.  Let me explain step by step. 1. Look at the commit log & count commits This is the first step. First let's list the commits using the following command,  

As always, let's start with a story why I have written this one down. I have been using git for almost 5 years now and in one of my work places I had to work on the same project but different features in parallel.  Switching between branches back and forth was a costly operation given that I didn't discover commit amend until recently. Even though I'd have discovered commit amend, I'd still have did this. Still did what? I can sense that question deep from your throats. So, whenever I am in a situation to work on multiple features or a feature and a bug fix, I'd have two clones of my repo each with different branches, Whenever a feature is merged or the fixes are merged, I'll delete the clone in my machine and branch in my origin (Gitlab / Github etc.,) Recently when I started writing these git articles, my manager suggested me to learn about Git Worktree and it'll be useful. And when I got free and good understanding of git commit, rebase and stuff, I decid

I have already written on getting started with TDD . Let me extend it further and mention in theory what are all the phases involved in a TDD. Before jumping into this article, I hope you read the getting started with TDD article.   There might be more steps involved in TDD. However we're just going to discuss the phases of TDD and what do we do in each phase. /**  * @disclaimer  * I'm just preaching what I have learnt & practice   * Some parts of it could be wrong  * Please feel free to leave comments if am wrong  * And I would be happy to stand corrected */ The three phases of TDD are the, Red phase Green phase Blue phase Red phase This is the very first phase in TDD where we write a test for it to fail.  Green phase This is the second phase and immediate next phase to red phase where we write code for the test that we just wrote in the red phase to pass.  Blue phase This is the third and final phase of a test where you refactor the test to simplify it down further. Thes

I had this interesting scenario where I did hard reset and force push to a commit. However I wanted one of the change from the lost commit.  Once again, Git magic came in handy. Git never erases anything off its memory too soon. This magic spell as I call, is one of a kind and most git enthusiasts must know it by now.  Introducing reflog We all know what you get when you do git log . Let me anyway spell it out, git log gives you a list of changes or in other words, commits available as of the moment in that local repository in the chronologically descending order.  Similarly, git reflog gives you a list if changes or in other words, change history that happened in that local repository in chronologically descending order. For instance, if you have amended the same commit 5 times, you can choose to go back to the 3rd commit amend and restart your work from there. This situation is what I call as,  Bring back from the dead Let us consider the following scenario, You worked and pushed a

So, it's only recently I've been doing TDD. I have written unit tests before but those were all tests after writing the actual code. Confusing statement right? /**  * @disclaimer  * I'm just preaching what I practice and some parts of it could be wrong.  * Please feel free to leave comments if am wrong  * And I would be happy to stand corrected */ What is TDD? TDD, expanded as Test Driven Development could have this statement as one of the definitions. "TDD is nothing but the art of writing down the business use case one by one and write code based on it paralelly" It would feel like why do I need to write test for that? We could do the same with pen & paper and write codes. But then, you again circle back to write tests for the same. So why not do it this way?  Therefore, let's start with an example, Write a method that accepts two positive numbers as input and returns their sum Let's try and do a mock TDD for the above problem.  Case 1 - Function add

So, this one another thing that can mess up our repo if you don't do it the right way.  Let's go over it step by step, Pulling latest changes of upstream to your local repo Merging (or) Rebasing 1. Pulling latest changes of upstream to your local repo. So, what's the big deal? We could do git pull to get latest changes from origin to local. That's what I had been thinking until I actively started working with Github and the forked repositories. Git pull won't work here because pull could pull changes only from origin and not upstream. Now, what is origin? what is upstream? Origin - It's the repository of yours that you cloned from someone else's Upstream - It's the repository from which you created your fork Here are the steps, Set upstream URL. git remote add upstream {URL_OF_UPSTREAM} Please perform this only for the first time. After that it is set to your configuration just like username and email Now do, git fetch upstream . 2. Merging (or) Rebas