My Job Went to India (52 meditations for the 21st century programmer)

Last night I finished reading Chad Fowler's My Job Went to India (And All I Got Was This Lousy Book).

It's a gold mine of savvy advice on how to increase your value to the business and your marketability in the software industry in the midst of increased offshoring. Sprinkled throughout are shiny little jeweled anecdotes relating Chad's experiences setting up a team of software developers in Bangalore, India for a large corporation.

His main premise is one worth taking to heart: simply "coding don't cut it anymore. " You have to invest in and guide your career, wear many hats, always be looking for ways to understand your business better while bringing more value to it, actively promote yourself at work and within the software community, and never stand still. I guess you could say if we want to make it to the next stage of evolution, we have to learn to swim like sharks but play together like dolphins.

This is a timely read for me personally because the company I work for add value to is being purchased by GE, that very same company that Chad worked for in India.

I especially liked the format of the book. Each chapter is a quick read (a perfect addition to your bathroom reading :) ) and ends with a list of action items (Act on it!) to help you put his advice into practice.

New Ruby <=> CLR bridge in the works

John Lam is working on his own version that promises to be faster. Sweet.

As businesses and startups increasingly avoid Microsoft for various reasons - high cost of licensing and compliance administration, unpredictable cost of upgrades over the long-run, and concerns over security - wouldn't it be smart if your .NET business layer could be ported to *nix without having to convert your C# and VB.NET to Java, PHP, or Python?

Speaking of Python, has anyone heard anything new about IronPython?

silicon flashback

A couple of buddies and I were reminiscing the other day over the computers we had in our jaded youth. I guess that makes us real geeks since we weren't reminiscing over old girlfriends.

This inspired me to produce a list, in order of acquisition. This doesn't include the PCs I've used at my places of employment - just ones I've owned.

1. Radio Shack TRS-80 Color Computer


2. Commodore 64


3. Atari 800 (fun games!)


4. Apple ][e (my dad's but i used it when he wasn't looking)


5. Mac Color Classic (not in use, still works but makes a funny crackling noise)


6. Compaq Presario 1610 Laptop (not in use, but still works)


7. Power Macintosh 7500 (Loaned this to a friend but never got it back. Had it running Yellow Dog Linux at one time.)


8. Power Macintosh G3 (Blue & White) (currently my iTunes music server)


9. Custom built Pentium III, 500mhz (now a Gentoo Linux development server)


10. PowerBook G3 (Bronze Keyboard) (not in use right, but it still works)


11. PowerBook G4 (15" FireWire 800) (daily workhorse)

I suspect the TRS-80, Commodore, Atari, and Apple ][e may still be at my Mom's house.

I predict number 12 will be an Intel PowerBook.

REST on Rails article

Matt Biddulph has an intriguing article on how to use xml templates and Rail's built-in class reflection to expose a CRUD interface to your models.

You could take his module file, put it in your appname/lib directory, include the following into your application.rb or environment.rb along with an authorization method:

class ApplicationController < ActionController::Base
  include RestResource

  def authorize 
    unless session[:user_id] 
      ...
    end 
  end 

end

then call the method in your class along with an authentication filter:

class AdminController < ApplicationController

  rest_resource :product
  rest_resource :order
  rest_resource :user
  before_filter :authorize

  ...

and you've got yourself an authenticated REST service for listing, updating, deleting, and inserting your models.

You don't even want to know what something like this would take with .NET. And you really wouldn't want to do it because you'd essentially be exposing your data to the mercy of the client. But with Rails, you still get the same validation logic provided by your controller as if you were building a separate service API.

Of course, you'd still bypass any other logic in your controller methods so this would not be a good approach to take for all your model classes.

Riding the Rails with Locomotive

After having some trouble compiling lighttpd on my powerbook, and not really feeling like updating my version of automake, I decided to try Locomotive which includes lighttpd, mysql and postgresql bindings, SQLite, and bundles for Rails 0.14.1 and Rails 0.14.2. Installation was drag-n-drop per all good Mac software, it doesn't interfere with your current Rails installation, and thus far the operation has been seamless for me.

I really like the way they are integrating it with other Rails/Mac-centric tools like TextMate (you can open your project via a menu) and preferences for the Mac OS X terminal or iTerm. You can also preview apps in the default browser (no preferences for different browsers).

The interface is simple, clear, and unpretentious. Just like RoR!

Imagine my surprise. Christmas in November?

ActiveState's Komodo + Ruby + RoR + Mac OS X?

Haven't tried it yet. It will have to really shine to supplant TextMate. But if the debugging works out of the box (I haven't gotten Eclipses to work yet on my powerbook) and it has good support for Rails, then it could be a contender for the toolkit. Especially given its support for Python, XSLT, PHP, and Perl.

rubyconf next year, fer shure

I am so disappointed that I couldn't make rubyconf this year. Looks like a great bunch of smart folks sharing their enthusiasm for this wonderful programming language.

Ah well, I will do my damnest to make it in 2006. In the meantime, I'm going to attend this month's Seattle Ruby brigade come hell or high water.