Sergio Pereira : Development

More on blocked files

sergiopereira — Thu, 24 Jun 2010 03:26:00 GMT

I've written about this before. You download a file to use in your web application, like a JavaScript library or an image file but the browser just can't seem to load it. You spend hours looking for a typo or broken link until you find out about that Unblock button and you realize that it's IIS that isn't serving the file. The file had been there; you had the correct URL all along; it's just disallowed.

I actually developed the reflex to right click and unblock each an every file I download now. It's stupid, isn't it? I should have imagined there was a way to disable that Windows feature instead of just learning how to live with the problem.

Well, no more. Here's how you can disable it. Credit goes to this article.

Run gpedit.msc (the group policy editor)
Go to User Configuration/Administrative Templates/Windows Components/Attachment Manager
Find the setting named Do not preserve zone information in file attachments and enable it
Log off then log back on, or update the current policies with: Gpupdate /force in any command prompt.

Note: If you're using Chrome it looks like there's some bug that may or may not be taken care of as you read this. Chrome doesn't seem to honor the policy setting and always mark the downloaded files as unsafe.

Now I just need to add this to the list of tasks anytime I get a new machine or repave one of them.

The Ground is Shaking Again. Get Mobile.

sergiopereira — Thu, 17 Jun 2010 05:08:00 GMT

A little over two years ago I commented how surprising it was that VisualBasic was still more popular than C# in the .Net world. Back then I checked the TIOBE Index and saw that VB (in all its flavors) enjoyed almost 11% of relevance while C# wasn't even at the 4% level.

When we look at the June 2010 rank below we see that C# has finally caught up with VB, and it's safe to say C# is now the most popular .Net language (remember, the VB index is not made up of just VB.NET.)

1	Java	18.03%
2	C	17.81%
3	C++	10.76%
4	PHP	8.93%
5	(Visual) Basic	5.87%
6	C#	5.20%
7	Python	4.27%
8	Perl	3.20%
9	Objective-C	2.47%
10	Delphi	2.39%
11	JavaScript	2.19%
12	Ruby	2.07%
13	PL/SQL	0.79%
14	SAS	0.70%
15	Pascal	0.70%
16	Lisp/Scheme/Clojure	0.65%
17	Lua	0.59%
18	MATLAB	0.59%
19	ABAP	0.58%
20	PowerShell	0.53%

Again, anyone can debate the importance of this ranking system, but at least it has been there for a while and to me it seems to represent the pulse of software development quite well.

Movers and shakers

But this post is not about C# vs. VB.NET.

This time around what caught my attention was the impressive rise of Objective-C (up 36 positions in one year). Now, no matter how more common Macs have become in the last few years, no one will convince me this increase in Objective-C is due to native OSX application development :)

Of course we all know it's caused by the surge in mobile and device app development (iPhone, iPad, and anything that they decide will run the iOS, like the AppleTV in the future, who knows?)

If you look at the trending chart on the TIOBE page you'll see that Objective-C started to gain significant steam around June of last year, coincidentally (maybe not?) when the iPhone 3GS was announced.

Keep your eyes on the ball

Are you playing with Mobile yet? Have you:

Started reading about mobile development?
Developed a Mobile web site?
Written and tested a native app against a device emulator/VM (iPhone, Android, WebOS, WP7)?
Written and deployed an app to your own mobile device?
Published an app on the market?

It's not like you will find yourself out of a job if you don't get into mobile but for many developers, from software shops to corporate environments, sooner or later a request for a mobile product or a mobile version of an existing one will swing by your desk.

It's an exciting time. Once again you have the chance of taking the lead and play an important role in your team by staying ahead of the game. Remember when you started seeing request for Ajax and fancy UI's in your web applications. Remember how you were one of the few that knew anything about it in your team? Same thing here. Only much bigger.

What I'm looking into

There are two different fronts that interest me in mobile development: Native Android apps and Mobile Sites. I'll explain.

The time I spent in Objective-C and XCode in the past was enough for me to know I'd be grinding my teeth and blowing off steam every single day if I wanted to develop for the iPhone (it's probably just me, I can live with that admission.) Besides, I don't like the idea of an approval process before I can give away or sell my apps.

Windows Phone is something that I'll have to wait more and see what kind of traction it gains. It also has the approval process issue. The big plus will be the development tools, which I think will better than iPhone and Android.

All that, combined with the enormous momentum that Android has, made me start coding for Android when it comes to native apps.

Don't forget Mobile Web

Native mobile development is fun and rewarding but let's not kid ourselves. History shows that businesses will favor the simplicity of web development.

I went through that transition period when custom desktop application development quickly lost market to web applications. And that happened in a world where Windows was virtually in every workstation that mattered.

Now imagine the mobile scene, where there's more than one big player, none equivalent to what Windows was back in 1998. Do you really think anyone will want incur the cost of maintaining 3 or 4 different native versions of each mobile application that we will start cranking out like we do web apps today? Native apps will probably be the minority, for environments where you have the luxury of dictating your end-user's choice of mobile device.

Didn't we just spend the better part of the last 10 years trying to get out of a certain single-browser paradigm? Do we want to repeat that mistake?

Moving to HTML5

Why is HTML5 so important in Mobile and not as much in the standard Web yet? Well, for one there is a greater percentage of HTML5-capable browsers in Mobile than on the desktop browsers. Android, iPhone, WebOS (and soon BlackBerries) have WebKit browsers.

With things like richer forms, offline support, canvas, video and the Geo-Location API (not really HTML5 but present in those WebKit browsers) we can build really capable mobile web apps. Not just small screen versions of the regular web apps.

To be very straight forward about it, the way I personally see it is that HTML5 is where the bulk of the mobile development will happen in the Enterprise and consumer-facing applications.

Maybe something like Flash, AIR, or Silverlight makes a run for their mobile money too but with all the bullying from Apple and diverging opinions everywhere, that's not something I'm spending time on right now.

Native or Web?

Both. But definitely much more of the Web kind.

Oh, no. My TortoiseSVN overlays are missing

sergiopereira — Tue, 05 Jan 2010 09:13:00 GMT

It's a matter of time. Good were the days when almost no application knew how to put overlays on your file icons in Explorer. These days it seems this is the coolest thing ever and virtually all file system type of utilities want to add their own.

Sooner or later you will install some utility and not notice anything different. But after the next reboot, poof, your TortoiseSVN overlays are gone. And, depending on how much time elapsed between the utility installation and that reboot, you may not have the slightest clue of what happened. Reinstalling TSVN won't fix it

TFS Power tools, Dropbox, Mozy, stop breaking my TSVN overlays

I should not blame these applications for a Windows shell limitation. To be fair, TSVN is the greater offender of them all.

It seems that the shell only supports 15 different icon overlays and TSVN creates 9 of those. After 15 the shell starts ignoring the extra ones. The trick is that Windows chooses the first 15 alphabetically from their entries in the system registry.

I love simple fixes

The fix is rather obvious; just make sure the overlays you want to be active are registered alphabetically before the ones you can live without.

Open the registry editor and go to HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\ShellIconOverlayIdentifiers and look at all the child keys in there. It will be obvious that, if you want to preserve the TSVN overlays like me, you need to keep the ones starting with Tortoise* before the other ones.

If you look at the image below you'll see that I changed my entries by prefixing the undesirable ones with z_, following someone else's suggestion.

After that change you just need to kill and restart explorer.exe using Task Manager (or logoff or reboot the machine depending on your tolerance to pain.)

I believe this is a common problem so I hope this tip helps somebody.

Test-Driving a new feature for JavaScript

sergiopereira — Fri, 13 Nov 2009 01:16:00 GMT

Earlier this week I had a piece of JavaScript that I wanted to like this:

var index = someArray.indexOf(someObject);

The problem there is that the indexOf method of the Array object was introduced in JavaScript 1.6, which isn't implemented in all browsers (actually, IE seems to be the real problem here).

Anyway, thanks to the awesomeness of dynamic typing and prototypeal inheritance in JavaScript, we can fix that ourselves with code similar to the below.

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(item) {
    // implementation goes here
  };
}

Actually, if you're just looking for the final solution you can find it easily with your search engine of choice or skip to the bottom of this article.

But, instead of going through the normal trial and error approach, I chose to flex my TDD muscle and try to create this method using a test-first routine. For this exercise, I chose QUnit as the unit testing framework.

I started with a standard empty testing HTML file where I'll put my test cases and a reference to my-library.js where I'll add this new method.

<html&gt
  <head>
    <title>Tests for mylibrary.js</title>
    <link href="testsuite.css" rel="stylesheet" type="text/css" />
    <script src="jquery.js" type="text/javascript"></script>
    <script src="testrunner.js" type="text/javascript"></script>
    <script src="my-library.js" type="text/javascript"></script>
  </head>
  <body>
    <h1>Tests for mylibrary.js</h1>
    <h2 id="banner">
      <span style="color:#fff;">Result: Red/Green?</span>
    </h2>
    <h2 id="userAgent"></h2>
    <ol id="tests"></ol>
     <!--
        The #main element is like your test fixture. It's like the 
		data for your tests.     
        Whatever exists inside the #main element gets restored 
        before each test.
        Feel free to manipulate the contents of #main in your tests.
      -->
    <div id="main">
    </div>
  </body>
</html>

You can put your test cases in a separate .js file and reference it here but I'll just add the necessary JavaScript to the HTML file itself in this exercise.

Here are the test cases I'm going to support:

Missing items return -1
Existing item is found
Existing item is found with positive starting index
Existing item is not found with positive starting index
Existing item is found with negative starting index
Existing item is not found with negative starting index
Comparison is non-coercive

Let's start with the first test: Missing items return -1. It's a simple value comparison. At this point I do not have anything written yet for the indexOf function, it doesn't even exist if you're on IE. Add the following to the HTML file.

$(function() {
  var list = [11, 22, 33, 44];
  
  module('Array.indexOf');
  
  test('Missing items return -1', function() {
    equals(list.indexOf(1234), -1);
  });

});

When you open the HTML file on IE (I'm using IE8), you'll see this:

Totally expected, but let's try to make this test pass. In the my-library.js file, let's add the simplest code that can satisfy that test.

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function() {
      return -1;
    };
}

The outer if is there just to prevent replacing the function if it already exists. The function is clearly incomplete, but that's not the point. The point is that it passes the test:

Great. Time for the second test: Existing item is found. For that one we will need to loop through the items in the array. The array is this in the method. Here's the test, which we add right after the first one.

test('Existing item is found', function() {
  equals(list.indexOf(22), 1);
});

And of course that fails

Time to make it pass.

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(item) {
    for (var i=0; i<this.length; i++) {
      if (this[i] == item) {
        return i;
      }
    }
    return -1;
  };
}

And it passes:

Now let's tackle the third test case: Existing item is found with positive starting index. This one starts to make things interesting. Here's the test.

test('Existing item is found with positive starting index', function() {
  //let's try a few boundary conditions
  equals(list.indexOf(33, 0), 2);
  equals(list.indexOf(33, 1), 2);
  equals(list.indexOf(33, 2), 2);
});

Hmmm. The test passes, as we can see below. Well, that was kind of an accident but I'll leave the test as is because it does test what was specified. Leaving the test will help us if we make changes that break this specification.

The next test case is Existing item is not found with positive starting index. We could write it like this:

test('Existing item is not found with positive starting index', function() {
  equals(list.indexOf(33, 3), -1);
  equals(list.indexOf(33, 1000), -1);
});

And boom! It fails. It should, we don't even have support for that second parameter yet.

Failing it is, pass it we must. First attempt:

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(item, startIndex) {
    for (var i=startIndex; i<this.length; i++) {
      if (this[i] == item) {
        return i;
      }
    }
    return -1;
  };
}

It passes the new test, but it fails another one:

That's actually pretty cool. We would have created a mess if we had just added the second parameter without some regression testing. Hooray for unit tests!

What's happening is that my startIndex defaults to undefined if not passed by the caller. It should default to zero. Easy fix.

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(item, startIndex) {
    startIndex = startIndex || 0;
    for (var i=startIndex; i<this.length; i++) {
      if (this[i] == item) {
        return i;
      }
    }
    return -1;
  };
}

I see the green light!

Our next test case is up: Existing item is found with negative starting index. What we are trying to do here is allow the caller to specify the starting position as an offset from the last item using a negative number. So in a 4-element array, passing -1 means that we start at the last item and passing -3 we start at the second item. See the test.

test('Existing item is found with negative starting index', function() {
  equals(list.indexOf(33, -2), 2);
  equals(list.indexOf(33, -3), 2);
  equals(list.indexOf(33, -1000), 2);
});

Once again it passes by accident.

The next text case will show that it was an accident: Existing item is not found with negative starting index. The test for that is below:

test('Existing item is not found with negative starting index', function() {
  equals(list.indexOf(33, -1), -1);
  equals(list.indexOf(11, -3), -1);
});

It fails:

Making it pass is not that hard, we just need to compute a positive version of that negative start index.

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(item, startIndex) {
    startIndex = startIndex || 0;
    
    if (startIndex < 0) {
      startIndex += this.length;
    }
    
    for (var i=startIndex; i<this.length; i++) {
      if (this[i] == item) {
        return i;
      }
    }
    return -1;
  };
}

Ding, ding, ding! Another passing test for our team.

Lastly, we need to make sure that the Comparison is non-coercive. By that we mean, a number will never equal a string — or generally speaking, the things being compared must be of the same type. Let's get some tests that try to point out tha flaw in our current code.

test('Comparison is non-coercive', function() {
  equals(list.indexOf('22'), -1);
});

This fails because, strictly speaking, 22 and '22' are two different things and we didn't want to match that element like we did.

On to the fix. Can you spot the difference? Try harder.

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(item, startIndex) {
    startIndex = startIndex || 0;
    
    if (startIndex < 0) {
        startIndex += this.length;
    }
    
    for (var i=startIndex; i<this.length; i++) {
        if (this[i] === item) {
          return i;
        }
    }
    return -1;
  };
}

And here is the QUnit report in all its successful glory.

If you've never been exposed to TDD this may have felt awkward but hopefully you noticed that it's more of an evolutionary design approach, as opposed to trying to make it perfect on the first attempt or even reckless patching.

It also left us with a valuable collection of tests that we can execute after making changes to the code, ensuring we didn't break anything by accident.

IE6 still haunts me

sergiopereira — Wed, 21 Oct 2009 22:16:00 GMT

Oh, the woes of supporting IE6 (or, better put, IE666 — the browser of the beast.)

Halloween is definitely upon us. Today I spent a good chunk of time trying to identify the source of a problem in my application. Right now I'm in the process of jQuery-fying some legacy JavaScript, which includes Ajax calls and error handling logic.

At some point I needed to pop-up a DIV that was supposed to look like a modal message box, reporting some error that happened during the Ajax call. That was not hard at all. I used the SimpleModal plugin and got the message box up in not time at all.

Not so fast, you have IE6 users

As with many web developers out there, I don't have the luxury of ignoring IE6 users because they are upwards of 60% of our user base (corporate users that for some reason can't easily upgrade their browsers.)

I thought it wouldn't be a problem because the SimpleModal plugin handles a number of IE6 issues, including the insertion of an IFrame to overcome the bleedthrough of Select tags. But of course it couldn't be that easy right?

In some of my tests IE6 was simply crashing when I tried to open the "modal" message. After a lot or hair pulling, I saw this suspicious HTML in one of my messages:

<table style="font-size: expression(parentnode.currentstyle.fontsize);" >
    <!-- rest of the table is normal -->
</table>

Sure enough, moving that hack to a proper CSS rule in the external .css file made the error go away. We shouldn't be using dynamic CSS expressions anyway, since they were removed from IE8, so I went ahead and ditched that kind of usage wherever I could find it.

This is just to keep us on our toes regarding IE6 support. Even though the modern JavaScript libraries go to great lengths to support IE6 and make our coding transparent, nothing substitutes good old manual testing to make sure IE6 doesn't play pranks on us in production.

JavaScript and its love for zeroes

sergiopereira — Sat, 19 Sep 2009 13:54:00 GMT

This post is part of a series called JavaScript Demystified.

Answer quick. Do you know what date is being created here?

var year = '2009', month = '09', day = '01';
var date = new Date( 
             parseInt(year),
			 parseInt(month),
			 parseInt(day)
			 );

At first glance, it wouldn't surprising that someone guesseed September 1^st 2009. However, I'd not be writing this post if that was the correct answer, right?

There's an interesting and tricky thing with the JavaScript parseInt function: it can parse strings with a numeric value in the decimal radix, but also in other radices. See the following examples.

//passing the radix explicitly
parseInt('1011', 10); // ==> 1011
parseInt('1011',  2); // ==> 11
parseInt('1011',  8); // ==> 521
parseInt('1011', 16); // ==> 4113

Maybe you thought that if you didn't pass the radix, then it would default to 10 because it's the obvious behavior. Well, no. In JavaScript the default behavior is to try to identify one of the literal formats and interpret that. So here's that in action:

//leaving JavaScript on its own
parseInt('1011'); // ==> 1011 (decimal literal)
parseInt('0x12'); // ==> 18   (hexadecimal literal)
parseInt('0511'); // ==> 329  (octal literal)
parseInt('0182'); // ==> 1    (whaaaa?!?!)

If you are familiar with the literal notation for integer numbers in JavaScript, and after I explained the default behavior of parseInt, then you probaly understood the results shown above. Well, maybe the last one deserves some comments.

When JavaScript is parsing the string, if it finds a digit (number or alpha) that is invalid in the chosen radix, it stops right there and parses only the portion of the string that comes before that digit. So, since we started '0182' with a leading zero, the octal radix is assumed. Then, because 8 is not a valid octal digit, only '01' will be parsed, which becomes 1.

Tip #1: If there's any chance the string value you plan to parse into an integer number has a leading zero (or a less likely 0x,) then be safe and pass the radix parameter to your parseInt call. If you're extra paranoid, then always pass the radix.

Back to our original question

Armed with the clarification made above, we can expand our example like this:

//given:
var year = '2009', month = '09', day = '01';
// then the following statement:
var date = new Date( 
         parseInt(year),
         parseInt(month),
         parseInt(day)
         );	
//...is equivalent to:
var date = new Date( 
         2009,
         0,  // ===> oopsie
         1
         );

Hmmm, a zero in the month parameter. Will we have an error here? No, here comes the second potential surprise of this post.

Tip #2: When creating a new date using new Date(year, month, day), the month parameter, and only the month parameter is zero-based (0 to 11).

So, in case the tips and the picture in this text were not enough to help you guessing the date being created, here goes another completely gratuitous one with the answer.

Taming Firebug with Profiles

sergiopereira — Tue, 01 Sep 2009 10:03:00 GMT

This is a tip for anyone using Firefox and Firebug for web development that is not leveraging the Profiles feature of that browser.

Recent versions of Firebug (after v1.3 I think) removed the ability to enable Firebug panes on a per-domain basis. Now it's kind of all or nothing. And you know that you don't want to have Firebug enabled when using Ajax-intensive applications like GMail, for example.

The end result is that you are stuck in this annoying dance of of enabling/disabling, open/close Firebug when switching tabs.

There are some workarounds for that but I think the best solution for this problem is through Profiles, which is also a very nice approach for web development overall.

Firefox Profiles

Firefox stores all your preferences (add-ons, state, saved passwords, history, etc) inside profile directories. It installs a default profile and that's perfectly enough for the casual browser user. Web developers, add-on developers, and power users in general, on the other hand, can find handy uses for extra profiles.

You can see your profile directories in %APPDATA%\Mozilla\Firefox\Profiles (or, on the Mac, ~/Library/Application Support/Firefox/Profiles).

Development profile

The suggestion I'm giving is to create a separate profile just to be used during web development work. That way you can exclude some of the add-ons (like ad blockers, bookmarking extensions like Delicious, and any other non development-related extensions.) The opposite applies to your default profile — you can now remove all the development stuff from that profile and keep your browser a little lighter. In addition to that I use a different skin/theme in each profile, just to make it screaming obvious which one I'm looking at.

Here's how we create a new profile. First close all your Firefox windows and make sure there's no Firefox process running in the background. Now go to the command line and enter this:

(on Windows)
%ProgramFiles%\Mozilla Firefox\firefox.exe -ProfileManager
(or on the Mac)
/Applications/Firefox.app/Contents/MacOS/firefox -ProfileManager

This will bring up the Profile Manager, where you can easily create a new profile. Create one named Development and start it.

Once started, you'll notice that Firefox will open looking just like it did the first time you installed it. You can now install your favorite extensions for web development (like Firebug, YSlow, Web Developer Toolbar, User Agent Switcher, etc)

To launch Firefox using the the Development profile you can create a shortcut that passes some arguments to Firefox, like firefox.exe -P Development -no-remote. For example, I added that shortcut to my Desktop, Quick Launch, and Launchy. (Firefox will remember which profile you started last using the Profile Manager, and use that one next time you start Firefox without explicitly choosing a profile. You may want to leave the default profile selected in the Profile Manager.)

More uses for Profiles

Besides creating a profile dedicated to web development work, I can very well see myself eventually creating extra ones for different activities, like a Presentation profile and a NoAddons profile, for example.

Circular Refactoring

sergiopereira — Fri, 14 Aug 2009 17:21:00 GMT

One of these days I was chatting with Derik and we were talking about refactoring and when to stop refactoring. We thought it was funny (and embarrassing) how sometimes, after a few consecutive refactorings, we are back at the starting point.

This type of Circular Refactoring is a real productivity enemy. In our genuine desire to improve the code, and wishing to dive into an interesting task, we sometimes lose sight of the code history and the real need for this change. It reminds me a lot of this funny comment (second part).

How do you tell when you're being a victim of this variation of the premature optimization monster? Well, here's a start:

Top 10 signs you've fallen into circular refactoring

9 - Code gets eerily familiar by the minute.
8 - Your git repository doesn't seem to grow.
7 - Work feels too much fun to be real.
6 - Your code metrics trending charts look like Bart Simpson's hair.
5 - You're never breaking any of your unit tests after each change.
4 - You've created macros in the IDE to help with almost all the steps.
3 - You're refactoring your macros.
2 - Clippy is asking if you've heard about the "svn merge" command.
1 - TFS, on the other hand, still can't offer you much help.
0 - Your Find/Replace drop-downs seem to read your mind.

A Craftsman sometimes has to create his own tool

sergiopereira — Sun, 28 Jun 2009 15:15:00 GMT

Today I was reading the latest one of the many excellent blog posts Patrick Smacchia has put out on the topic of code metrics and caring for your code's quality.

The passion this guy has for that topic is such that he has created the best tool for analyzing your code. But he doesn't stop there. He wants to make sure we understand what is going on behind the seemingly magic CQL queries that ship with NDepend. He wants you to understand your code's DNA; with the added bonus that you can actually improve that DNA.

That's Science with capital S.

First you understand the problem that you are trying to fight (code complexity/unmaintainable software,)
you research ways to quantify it (the metrics,)
you create some tool or device to extract that information from your subject,
you extract the metrics from a familiar subject,
you apply your knowledge of how #2 relates to #1 and improve the subject under analysis,
you use the tool to verify the metrics have improved,
time shows you that the changes you made indeed reduced the problem at #1

I simply hate when someone criticizes Patrick's posts as being just marketing material for his product. Let me tell you this. If I had that much dedication for software quality, to the point that I had created a great product to empower everyone, I'd also be trying to explain the problem to you using the tool I wrote. Heck, I'm pretty sure if someone else had written NDepend Patrick would still be writing about these things and using the tool in the process.

I like code metrics and static analysis a lot as well, not nearly as much as Mr Smacchia though. I'm very excited that very soon I'll get to use it in our code base, in our CI server. I can't wait to learn more about this science and inflict positive changes in our code. Like everybody else, we know there's dirt and bad smells in our code and it's just awesome that there's a tool that can help us clearly identify, mitigate, and track it.

My hope is that I'll be able to come back here and share what I've learned about my code and how the process we went through to improve it.

So you've been hearing about this Git thing

sergiopereira — Tue, 02 Jun 2009 17:11:00 GMT

The ALT.NET universe in Chicago gets together again on June 10^th, this time to learn and talk about Git, the SCM you're probably tired of hearing people jabbering about and still have not taken the time to look at.

The presenter will be myself and I hope to explain how Git works and how it can be a good alternative even for non open source projects.

Git Without Puns

This month we will take a look at Git, a distributed version control system that has been gaining a lot of popularity since its introduction.

As with everything that is new and is touted as a replacement for an existing product, it's easy to try and map Git's functionality to Subversion, CVS or TFS for example. To better use Git, we should avoid too much comparison and also try to understand how it was built and how it works under the hood.

Here are the things we will be seeing and discussing in this session.

Brief tour of Git on Windows (SSH, PuTTY, Git Bash, GUI)
Git is distributed. How does that benefits me?
Git's object database.
Git's main objects (blobs, trees, commits and tags)
Git workflows. Choose or create yours.
Working with Git
- Configuration tips
- Create a repo
- Clone a repo
- Add/Commit changes
- Reference another repo
- Update repo (to/from)
- Branching, merging, rebasing
Hosting Git
Github, social project forking

The Chicago Code Camp has got you covered

sergiopereira — Tue, 19 May 2009 07:09:00 GMT

As a brief inspection of your RSS reader will quickly tell you, it's Code Camp season. Not to be left out of this party, the developers in the Chicago and Milwaukee areas have a great option this year.

The Chicago Code Camp, which happens on May 30th, is strategically located right between these two cities.

The agenda has been published and it's pretty exciting to see so many interesting and useful topics in a single event.

.NET still dominates the schedule but there's a lot of options for developers of virtually all walks of life. Here's a quick summary (we will have 33 sessions but some cover more than one topic)

.NET: 20 sessions
Ruby: 6 sessions
TDD: 6 sessions
JavaScript: 3 sessions
Functional Programming: 3 sessions
Cloud computing: 3 sessions
Python: 2 sessions
Java: 2 sessions

The bad part is that we can't be at all the sessions we'd like — there will be 5 or 6 concurrent talks. Here are some sessions that interest me in particular:

Those are only a few of the talks. I'm sure you'll be able to find sessions of your own interest. RSVP below. Hope to see you there.

Git, SSH, PuTTY, GitHub, Unfuddle, the kitchen sink

sergiopereira — Wed, 06 May 2009 09:09:00 GMT

After reading a good number of the guides for getting Git/ GitHub/ Unfuddle working correctly in Windows, I finally got it sorted out. I had to use a bunch of things I had not used before so I realized it's probably a good idea to share my findings, hoping to help someone else (and maybe myself again) in the future.

Local git is easier

Getting Git to run locally in Windows is not hard. It gets a little trickier when you want to work with remote repositories. Especially if, like me, you have little or no experience using SSH in Windows.

In this post I'll install and configure the tools that enable Git to work with remote repositories (e.g. post changes to a server), which I think is probably what a lot of people will want to do, even if you're just toying with Git or evaluating it.

You will need SSH for serious Gitting

The way Git will authenticate and communicate with hosted repositories like GitHub or Unfuddle is through an SSH tunnel. That means we will need an SSH client to connect to the server and Git will use that connection to securely transfer the repository data up and down.

In Linux or on the Mac, SSH is a trivial thing. It's just part of the default installation. For whatever reason, Windows does not come with an SSH client, so we need to find ourselves a 3rd party client.

PuTTY, a family of tools

Luckily for us, there's a free and very popular SSH client for Windows, called PuTTY. PuTTY is actually a family of utilities that play together to configure and establish SSH (and Telnet) connections.

From the PuTTY downloads page get the following programs and put somewhere in your hard disk. I like to put these types of things in a c:\tools\bin directory, which is included in my %PATH%.

Create your SSH key pair

The most common way to authenticate your SSH connection with the server is using an RSA key pair. The pair contains a public key and a private key. Typically these keys will be stored in two files — make sure that the private key file is in a directory location that only your user account has rights. I'm gonna keep both files in %USERPROFILE%\SSH (type echo %USERPROFILE% in a command window to see where yours is.)

To create a key pair we will use puttygen.exe. Just click Generate and then Save public key and Save private key. I chose to leave the password blank and trust that my directory security is enough to protect my keys. Let's assume I saved my keys at %USERPROFILE%\SSH\private.ppk and %USERPROFILE%\SSH\public.ppk, respectively.

We're not done with PuTTY yet

Before starting an SSH connection with PuTTY, we need to run Pageant.exe. Pageant is a background process that will handle the authentication requests. We will add our private key(s) in Pageant and it will keep them available for new connections, without the need to retype the password (if you entered one) every single time.

Run Pageant.exe, double click its icon in the notification area, and add your private key file. If you specified a password, it will now prompt you for that.

Phew! We are done with the SSH crap. Now on to Git. Finally.

Git via msysgit

There are a few ways of installing the git client in Windows, including downloading and compiling the source. But guess if I want to go down that route. Instead, let's just press the easy button and use a pre-packaged installer.

msysgit is what you'll want to install. Donwload the latest release from the site. The file name of the full installer, as of this writing, will be named like Git-[version]-preview[yyyymmdd].exe.

Run the installer accepting most of the defaults, with the exception of these two screens below. We want to Run Git from the Windows Command Prompt and Use PLink (PuTTY.)

After this we should have a working installation of Git. You should be able to use Git from both the Windows command prompt and from the Git Bash shell.

Register your public key with the remote server

Now we need to tell the server that hosts the remote repository that it should expect and accept SSH connections from our machine. The way we do this is similar in GitHub and Unfuddle. We just need to associate our public key with our account on that site.

For example, in my GitHub account settings there's a section called SSH Public Keys, where we can add all public keys that we own. Don't use the public key straight from your PuTTY public key file, it uses a different format. Instead, open Puttygen again and load the private key. The public key, in the right format, will be shown in the big text box at the top of the window. Copy that entire text and paste in a new key in your GitHub settings, as seen below.

Troubleshooting

After all that you should have all it takes to use Git in Windows. Until I got to this point I came across some problems. Here are some of them.

No supported authentication methods available. I got that error while trying to push changes because I either forgot to run Pageant or to add the right key into it. The full error is below.

C:\myproject>git push origin master
FATAL ERROR: Disconnected: No supported authentication methods available
fatal: The remote end hung up unexpectedly

The server's host key is not cached in the registry. Sometimes when connecting to a remote server for the first time, the PuTYY will output this message after your Git command.

The server's host key is not cached in the registry. You
have no guarantee that the server is the computer you
think it is.
The server's rsa2 key fingerprint is:
ssh-rsa 1024 [fingerprint here]
If you trust this host, enter "y" to add the key to
PuTTY's cache and carry on connecting.
If you want to carry on connecting just once, without
adding the key to the cache, enter "n".
If you do not trust this host, press Return to abandon the
connection.
Store key in cache? (y/n)

The problem is that Git will not read your keyboard input so you can't type "y" (or "n"). You have to CTRL+C out of it.

The fix for this, is to connect to your server initially using plink -agent github.com directly and then you'll be able to press "y" to cache the server's key locally (and not be prompted again in Git.) Enter "git" as the username if prompted. Now we can get back to Git without that prompt.

Now, that was nerdy

By now, if you got this far in this post, you're probably thinking this is too much work just to get a simple Git client working. I think the current situation reflects at least two things: the people behind Git are definitely not Windows users (d'oh, what a surprise) and the toolset is still relatively immature (in terms of polish, not under the hood) compared to Subversion and CVS for example. The existing GUI's are still very raw and young but, given the increasing popularity of Git, I'll be surprised if by the end of this year this problem isn't gone.

Taking PeepCode for a spin

sergiopereira — Tue, 28 Apr 2009 08:25:00 GMT

A rainy weekend and some brain hunger made me finally do something I had been meaning to do for a while. Once I posted about my interest in screencasts and their power to make information memorable. This last weekend I filled up my shopping cart over at PeepCode with a bunch of material that was on my to watch list.

GIT

This video was pretty interesting. It will definitely let you get off the ground quickly with git. I learned and still remember more from this screencast than from any other time spent on documentation and tutorials.

This is one of those screencasts where the author starts cranking out commands at the command line. If you can't stand the command line, you won't like this one. The advantage is that the command line is the same in all platforms.

My only negative comments, which is applicable to almost all the other videos I've watched, is that the author has the habit of clearing the screen way too early and often. At least it's recorded so you can rewind and absorb the information at your own pace.

GIT Internals (PDF)

While on my git learning mode, I went ahead and bought this PDF as well. Boy, this is money. If you're a sucker for internal details, this one is for you.

The PDF was written by Scott Chacon, who is very well known in git circles. The material is dense but is very well explained by Scott. Worth every penny.

The PDF ships with some videos from gitcasts and some handy shell shortcuts.

Rails from Scratch Part 1 and Part 2

I already have a reasonable level of experience with Rails. What made me buy these two episodes was to see a competent Rails programmer showing how he works. After watching both videos I was happy to see that I was not so far off. I know these screencasts are definitely simplified for the newbie and that a number of things changed in Rails since the first edition of this material, but the good advices on how to organize code and use the Rake tasks are still valid.

There's a whole lot more to Rails than it's possible to cram in 2h40 of screencasts but if you need to start somewhere, this is a good choice. I wish there was a little more ActiveRecord and plugins covered but, hey, it's still one of the greatest bargains out there.

Objective-C for Rubyists

I just started watching this one. My early impression (25 minutes in) is that its pace is a little too frantic. I don't buy the argument that knowing Ruby helps you learning Objective-C because of their SmallTalk heritage.

I've been trying to get into Objective-C from books and whitepapers but I had hopes a screencast like this would be more effective. I'm not too optimistic so far (I'll update this post if I'm convinced otherwise.)

Worth the investment

A good thing with the PeepCode episodes is that they are positioned at a price point (US $9.00) that doesn't let you feel too bad, even if you expected more of them. They have definitely been worth more than the sticker price.

I'm looking forward to a few more episodes later this year. RSpec and Haml are on my crosshair.

Blocked .js files keep biting me

sergiopereira — Sat, 04 Apr 2009 03:14:00 GMT

This is a tip for those working with JavaScript (and possibly other types of files) that is freely available for download. For the n^th time in the last few months I spent an unnecessary amount of time trying to find a problem in my code that wasn't really there.

Windows keeps track of the files you save to your hard disk which came from the Internet. Maybe you have seen this problem when you try to open a CHM file that you downloaded and see that it opens to a blank page. The same type of thing happens with JavaScript files that you download. Let's see what happened to me today.

First I downloaded the latest version of QUnit and saved to my application's directory. I did this the usual way, as shown in the image below.

Then I proceeded to use the downloaded testrunner.js file in my HTML page, via a <script src="testrunner.js"></script> tag. When I tried to open my HTML page, I was not expecting to see the particular error shown below.

I started to look for common problems: Did I save the file in the right place? Did I spell its name right? Did I mispell the function name? Did I miss a dependency? No, no, no, and no. All looked good.

That's when I remembered that the file might have been flagged by Windows. I opened its properties dialog and, sure enough, there it was, the infuriating Unblock button.

Ah, that's easy. I just clicked it and refreshed my page. Wah-wah! Problem persists. I tried typing the .js url in the address bar and saw this 401 error message from IIS, not 404.

That told me that there was still something messed up with file access. I checked the file's permissions, comparing to an older .js file in the application. The new one did not grant access to local users, so I added Read access to local users.

Now it works. Depending on how your IIS and/or ASP.NET security is configured, you may not need this last step (e.g. if the process identity already has admin rights, in which case I salute you, brave friend.) The system at hand was a Win2008-x64 installation with the default IIS/ASP.NET settings.

This problem seems to happen to me every other week and I still did not develop the reflex to take care of it right when I download the file. On the other hand, I'm getting better at remembering about it when I see stuff like "function not defined" in an error message.

Easy project administration with Unfuddle

sergiopereira — Sun, 08 Mar 2009 08:12:00 GMT

I don't come out often to sing praises for any product, I'd say I even tend to complain more than anything. That said, sometimes I come across a product that strikes all the right chords.

Recently I started using Unfuddle and ...just Wow! What a delightful experience. I can't say I was exactly surprised because I had heard really good things about it from a few people. Still, it's great to try it and confirm that same impression.

Unfuddle is clearly a product that was built with a lot of love and by people that understand the problem that needs to be solved.

Migrating a project - the Repository

I started moving one of my projects to Unfuddle. I started creating a new project and, with help from their support team, I moved my SVN repository (with the complete log history) into the project's repository.

The repository browser offers all you'd expect from a 1st class product. You can easily navigate the repository tree and go back an forth in the revisions trail. You can see what was changed in each commit, see the file by file diffs, and post notifications whenever a commit happens (great way to trigger your CI process.)

Managing the project

Right now I'm in the process of moving the list of bugs and planned features into the ticketing system. In Unfuddle I can plan milestones and version numbers for my project and associated tickets to them, which will let me see how far the project is from each milestone right in the project's dashboard.

Unfuddle reminds me of Trac, with the important difference that I don't need to go through the pain of getting it up an running and that configuring your project (or as many projects as you want) is much simpler.

One important thing for me in any product like this is the ability to create and maintain documents. This is provided through the Notebooks feature, which allows us to create collections of pages with basic formatting. If you need something much richer, like a diagram, or include an existing Word document, you can attach files to a notebook. A real file repository is probably a feature that could make Unfuddle even better.

Other nice things

I love how Unfuddle allows us to use Markdown or Textile to format pretty much everything that is important, like ticket descriptions and notebook text.

Unfuddle also supports git. I haven't been using git yet, but it's good to know that I'll probably not need to go looking for another service if I choose to migrate to git.

Very important disclaimer

Although I could probably get by with just the free plan in Unfuddle, I received a complimentary subscription to their Compact plan. The only important differences for my use cases would be the number of notebook pages and the ability to attach files.