Archive for January, 2009

RAM – who knew it could take out a computer?

Tuesday, January 20th, 2009

At one point or another I’m sure most of you have run across bad hardware. This past week I built a computer and was running into an odd situation. After about 2 minutes of running (or less) the system would completely lock up. Rebooting would sometimes make it to the login screen while other times it would just die part way through. Other times, the system wouldn’t event make it past the POST or show the BIOS loading screen.

Fearing a faulty motherboard, or inproper CPU installation, I decided to watch what was happening to the temperature in the BIOS. The temp was staying quite low ( < 30 C for both the CPU and motherboard) but, the system would still lock up… even in the BIOS screen. At this point I had detached everything except for the video card, 1 stick of RAM, and the hard drive and was still getting the same problem.

As a last ditch attempt, I swapped out the final stick of RAM for one of the other ones in the pile of components sitting beside the case. And what do you know, it worked!

Now, the only conclusion I can come to is that the RAM was overheating after about 2 minutes or so of use, and then completely ceasing to function. The bad memory addresses must have been quite close the beginning since even in the BIOS screen (where I’m assuming it doesn’t do all that much with RAM) would lock up.

Has any one else ever experienced something like this? For the record it was a Corsair 2GB stick.

git – commiting a portion of your changes

Sunday, January 18th, 2009

While code the other day I ran into a familiar situation where I wanted to commit just a few of my changes in a file instead of all of them. Some of the code was needed for a quick fix, but the rest was more in the building / testing phase. I know the better setup would have been to have a branch for the bigger change, and merge back when it was all ready to go, but unfortunately that wasn’t the setup this time.

Doing a bit of researching, I found that using git it is possible to commit some of your changes instead of all of them. To do this I have found the interactive commit command the most straight forward to use.

To begin an interactive commit,  issue the command with the –interactive flag (note, that’s two dashes, not the one long one)

git commit --interactive
           staged     unstaged path
  1:    unchanged        +3/-0 index.php
*** Commands ***
  1: [s]tatus	  2: [u]pdate	  3: [r]evert	  4: [a]dd untracked
  5: [p]atch	  6: [d]iff	  7: [q]uit	  8: [h]elp
What now

As you can see it gives you a number of options. In this case we want to patch the file so we hit ‘5’ and then hit enter.

What now 5
           staged     unstaged path
  1:    unchanged        +3/-0 [i]ndex.php
Patch update

This is showing us a list of files that we can choose to patch from. Hitting 1 will select index.php for patching. You have to hit return again to begin the process after a file has been selected.

Patch update 1
           staged     unstaged path
* 1:    unchanged        +3/-0 [i]ndex.php
Patch update
diff --git a/index.php b/index.php
index 90ea18f..e2f84ef 100644
--- a/index.php
+++ b/index.php
@@ -1,7 +1,10 @@
 this is a test of how to commit partial files
+this is the first addition to the file
 some more changes
+and another line goes here
 and some more testing here... this is fun!
 adding some content to the bottom of the file
+okay, last one for now
 and a couple more
Stage this hunk [y/n/a/d/s/?]?

Hitting ‘s’ will split the current hunk and show you the changes to the file one hunk at a time giving you the option to stage the change or not.

After you are satisfied with how you have things set up, hit 7 to quit when given the option and git will bring you to the familiar comment adding screen.

Doing a git diff right after doing this will show you that only the staged changes got committed, the rest are still waiting there for whenever you’re ready to commit them as well.