I neglected to feed my chinchillas for a day — then I fed them & was surprised to find myself in the midst of a …… CHINCHILLA FIGHT!!!!

Here are the top reasons I am a git fan:

- price. Depending in the implementation choice, it can be free (as in free beer!). Using a service like github.com to facilitate in a centralized workflow is super cheep. Currently for a year’s service for 10 developers we are paying about $25 a year per developer for the github service (and 20 “private” repositories). Scaled up a bit it’s relatively the same cost at $24 a month per developer for 1 year (100 developers, 300 private repositories).

- cheap local branching, merging & tagging. It’s sinfully easy to do. As fast as you can 10 characters and a branch name, it is done. It’s all local, so it’s virtually instant. Easy branching means you are more likely to do it & that can lead to better development as a whole. Isolating a feature, bug fix or re-factoring into a branch as a standard can be very rewarding. Merging is relatively straight forward, fast & in some cases completely automatic. Tagging allows for you to give the code a name at any point in time — like “release 1.2″, or “hotfix”. You can very easily switch to a given tag (or any commit) and work on it via a new local branch.

- Fast. everything is local. Besides syncing up with other people, pretty much every interaction with the source control is local. This becomes a huge time saver — and again, when it’s quick you are more inclined to use it. Branching, merging,  looking at code history and committing are all practically instant tasks. Yes, git is faster than most source control systems out there. Oh yeah, and all revisions of every file are always locally available for you to inspect. Again, this can be a big performance booster of you are comfortable with the command prompt. When you do need to do network opperations like pulls & pushes, it is also very fast. Git uses diffs and compression to make these also very fast. “raw, blistering speed.” Does that make you think of other source control systems?? no? didn’t think so….  

- several workflows. You can follow the traditional centralized repository approach as we currently do with github. A master repository is designated, and people pull/push to that repository using it as a centralized sync area. This is very similar to the perforce workflow. Alternatively though, there is a “Dictator and Lieutenants” workflow that basically allows for anyone to sync up with anyone else’s repository. A “circle of trust” is applied here each developer trusts other developers in their commits — and each developer trusts certain people with that they have contributed. This works well for larger groups. Think of a triangle scheme, with the sr. developer (the dictator) trusts a few others (lieutenants), and those lieutenants each trust a few others, etc.

- easy to learn. You basically learn what you need to do your tasks. You may only need to do a few things with the files you are putting under source control. Maybe you only need to know “git pull”.  If you only need to make sure you have backups of a file locally then you only need to know 1 or 2 commands. Done. If you are a source control master, there’s more git functionality than I can shake a stick at…. I get by using probably 2% of git’s core functionality. And when I need more, I do a google search & there’s a ton of user contributed info on how to accomplish a given task at hand.

The important thing to note here is that git has some major benefits in certain cases & although it is not for everyone, I think it has some major wins in certain situations.

As Mr. Natural said “Get the right tool for the right job”. In other words, one tool may not be a good fit for any job at hand.

Oh yeah, github.com is the bomb. Look out for http://fi.github.com. It look killer if you need a github UI but internally (possibly due to corporate policies / restrictions)

I felt compelled to post this because this book is just great & I wanted to share it with anyone who is interested. If you are just getting into behavior driven development (BDD), RSpec or cucumber then I have a book to recommend to you! Having heard nothing but good things, I recently purchased “The RSpec Book” by David Chelimsky, Dave Astels, Zach Dennis, Aslak Hellesøy, Bryan Helmkamp, Dan North from Pragmatic Programmers.

It’s a easy read that is packed with great tips on how to approach BDD – as well as detailed info on rspec’s features, and tons of other very useful stuff.

The book is in beta right now (not finished) but you can purchase & get the PDF right now. As updates are made you can re-download the PDF. Once the book is actually finished as paperback will be sent to me. I can’t wait!

Worth mentioning is that I  am just a fan — not affiliated with anyone who makes money from this, nor do I make any money for posting this or my website in general.

Rails 2.2 new features of interest
- Ruby 1.9 and JRuby support
- Transactional Migrations that allow multi-step migrations to be rolled into a transaction.
- Memoization for caching methods for a request. Allows caching based on passed params as well.
- *!* Connection Pooling lets Rails distribute database requests across a pool of database connections
- find_last_by_attribute finder, for example to get the last user who signed up from London:  User.find_last_by_city(‘London’)
- Layouts for ActionMailer – you can now use layouts in your ActionMailer views.
- *!* To avoid deployment issues and make Rails applications more self-contained, it’s possible to place copies of all of the gems that your Rails application requires in /vendor/gems.
# rake gems:install to install missing gems to the computer
# rake gems:unpack to place a copy of the required gems into /vendor/gems
# rake gems:unpack:dependencies to get copies of the required gems and their dependencies into /vendor/gems

Rails 2.3 new features of interest
- ruby 1.9.1 support
- Engines allow for nested rails applications.
- Metal allows you to define a area of code that completely bypasses most rails things – does not go through routing, no logging, etc – for areas that need high performance or that get called frequently.
- Nested transactions within ActiveRecord
- Dynamic Scopes: Order.scoped_by_customer_id(12).scoped_by_status(“open”)  — no definition needed for dynamic scopes, just works.
- Multiple Conditions for Callbacks. When using Active Record callbacks, you can now combine :if and :unless options on the same callback, and supply multiple conditions as an array:
for example: before_save :update_credit_rating, :if => :active,  :unless => [:admin, :cash_only]

Rails 3.0 new features of interest (David Heinemeier Hansson KEYNOTE FROM RAILSCONF09)
DHH’s Philosophy of rails 3:
- Lock up all the unicorns. You can’t please everyone all the time, so don’t focus on the unicorns.
- No holy cows. Nothing is sacred in rails & everything is up for debate. Don’t look any anything we have & feel like that is the way it has to be.
Major Themes:
- New routes. Faster, route by subdomain, user agents, etc. Rack to other rack machinery.
- XSS protection (cross side injection). By default all output in views will be escaped. No more use of <%= h something %>. Assumed by default.
- Javascript goes Unobtrusive & Agnostic. Much less JS is injected into page & instead unobtrusive JS is used to achieve same effect.
- More Agnosticism.
- Action ORM is a slim proxy wrapper for ORM tools that allows for easy swapping of ORM implementation,
- Generators (script/generator) will for example allow you to specify that rspec is used, so script/generate model will create a rspec test file for model.
- Refactoring
- Abstract Controller takes similarities between for example ActionController & ActionMailer and combines them into one code base.
- Cherry picking from ActiveSupport allowing you to pick parts that are used instead of pulling in the entire library.
- Increased performance / speed with callbacks.

Performance Optimization
————————
- optimization doesn’t end with speeding up my Ruby code (or Rails itself).
The performance of production application heavily depends on its environment – server filesystems, databases, load balancing solutions.

Testing
——-
- use gems like UnitRecord or dust to cut off the database for unit testing. Mock all unit tests out to speed things up drastically.
- to scale large tests you can offload them to remote BAMs(Bad Ass Machines), or send tests to multiple processors. Deep Test allows you to spawn multiple remote threads to run functional tests
- to benchmark a specific url you can use the ab (Apache HTTP server benchmarking tool) command:  ab -n 100 http://localhost:3000/quick_reply/list
- Errorlytics web service detects 404 errors via JS & redirects user based on rules that you define at errorlytics.com – http://www.errorlytics.com/
- Using factories instead of fixtures.
- Fixtures are more brittle & they seperate the data from the test, creating a assumption that the data already exists & is correct to begin with.
- Factories …. Fixjour, Factory Girl, Object_daddy and Machinist are plugins that aim at creating factories.
- Cucumber tips: http://media.railscasts.com/videos/159_more_on_cucumber.mov

Cucumber
——–
- Write tests first, the run cucumber. To run a specific feature run: cucumber features/name.feature
- Use output of cucumber to create stub step definitions.
- Make each test pass, from the top down.

Feature: title
In Order To [business value]
As a [role]
I want to [action] some feature

Scenatio: title
When [context]
And [more contect]
When I do [action]
And [other action]
Then I should see [outcome]
But I should not see [outcome]

Database
——–
- CouchDB is a new way to think about database storage. Schema-less design. http://couchdb.apache.org/

Video / Screen / Pod casts
————————–
http://railscasts.com/episodes
http://peepcode.com
http://pivotallabs.com/talks/
http://www.railsenvy.com/podcast
http://confreaks.com/events

<!–
Below is a list of my favorite applications for either OS X, Ubuntu linux, or Windows.

When I moved from windows to Ubuntu I kept looking for software that did what my favorite windows applications did. Similarly when I moved to OS X from Ubuntu I looked for more software that met my needs in Ubuntu or Windows. Although there are generally less options for OS X software, what is out there (or built into the OS) seems to work just as well or better than what I have been used to in my former favorite operating systems.

Here’s a list that I put together based on software that I use & applications that I would recommend for the three operating system types that I have had daily experience with.

It’s official. Apple’s Mac OS X is my favorite operating system.

Here’s the story if you are at all interested:

My first computer was a Apple IIe (that was before windows existed, of course). I then had a Mac SE (released around the time Microsoft windows was released). My parents then bought me a killer computer – it was a 100 mhz 486 that ran Windows 3.1.

I used windows for another 15 years. Windows 3.1, Windows 95, Windows 98, Windows 98se, Windows NT 4, Windows 2000, Windows XP…… Wow. Been there, done that. It was cool for a while because I didn’t know a lot. I kept learning & kept using windows.

Over and over again I had to deal with the same old Windows crap. Bad performance. Bad UI. Bad experiences in general…

So I looked for alternative solutions. I was anti-mac for a long time. I had hard feeling about mac because of the lack of software at the time, the proprietary hardware, the lack of auxiliary hardware, the high prices…. well almost all of that has changed (basically everything but the high prices).

I made a dedicated switched to Ubuntu a few years ago – meaning that I ran it as my primary OS & basically only ran windows when I had to & would do so via a virtual machine anytime I could. Ubuntu Linux is a beautiful operating system & idea in general. It has huge potential & has had a huge impact in the overall acceptance of Linux based operating systems.

I can’t say this enough. I love Linux. I also love OS X…

About six months my employer bought me a MacBook Pro. My goodness, I have not looked back.

Not only is it basically built on Linux, OS X has an amazing GUI and unparalleled stability. That’s what sold me. The GUI is more intuitive & less obtrusive then any windows or Linux solution I have ever encountered.

Compatibility is also amazing. Many Linux apps run under OS X, and if I ever need to I can run windows & ubuntu with great performance via virtual machines.

Stability is better than windows or ubuntu with my experience & my usage patterns. Adding and removing software, tweaking settings, applying system updates, etc all seem to not affect my system’s stability. Rarely do I have to restart my system or end applications.

Toss windows. Embrace Linux. Use OS X.

I was working with a colleague today who was kind enough to introduce me to autotest for continuous test integration. Change a file in your app & tests are automatically run for you… Nice.

screenshot of my mumble alert (top-right)

One thing that really stood out aesthetically was how status messages were passed to Growl (in OSX) for eye-pleasing popup notifications outside of a terminal window.

Being a ubuntu user, I started looking for a similar solution for linux. It turns out there is a great utility for linux that resembles Growl — it’s called Mumbles. The challenge was getting Mumbles to work with autotest.

After searching google, I found one post that got me started. This is a good post, but I had to fill in a few blanks to get everything to work.

Here’s what I did:

1. Install ZenTest:

sudo gem install ZenTest

1. Install Mumbles
   • grab the latest .deb file or source from the mumbles-project page:

   wget https://sourceforge.net/project/showfiles.php?group_id=193587&package_id=227998

   • test out mumbles by running:

   mumbles &

   mumbles-send ‘a title’ ‘it works!!’

   • assuming mumbles has been installed correctly, you should see a little notification pop up. I recommend that at this point you add mumbles to your system session so it will start when you login to ubuntu.

   gnome-session-properties

   add -> “mumbles” for name & command -> ok

2. Install ruby-dbus. I could not find a gem, so install manually:
   • grab the latest from https://trac.luon.net/ruby-dbus/

   wget https://trac.luon.net/data/ruby-dbus/releases/ruby-dbus-0.2.1.tar.gz

   • extract the archive to a local directory

   tar -xvf ./ruby-dbus-0.2.1.tar.gz

   • look over the README file — it provides simple instructions:

   ruby setup.rb config

   ruby setup.rb setup

   sudo ruby setup.rb install

   • test this out by requiring dbus via irb:

   irb

   irb(main):001:0> require ‘dbus’

   => true

3. Create a .autotest file in your application root directory (or your home directory to make the settings global) Thanks to CaffinatedCode for this script — they wrote it:

require ‘dbus’def send_message(title, message, icon)
begin
bus = DBus::SessionBus.instance
mumbles_service = bus.service(“org.mumblesproject.Mumbles”)
mumbles = mumbles_service.object(“/org/mumblesproject/Mumbles”)
mumbles.introspect
mumbles_iface = mumbles["org.mumblesproject.Mumbles"]
sig = mumbles_iface.signals["Notify"]
bus.emit(mumbles_service, mumbles, mumbles_iface, sig, title, message, icon)
rescue Exception => e
end
end

Autotest.add_hook :ran_command do |at|
begin
output = at.results.last.slice(/(\d+) examples?, (\d+) failures?(, \d+ pending)?/)
if output =~ /.*[1-9] failure.*/ then
send_message(“FAIL”, “#{output}”, “fail.png”)
else
send_message(“PASS”, “#{output}”, “pass.png”)
end
rescue Exception => e
end
end

Now for the fun part. From within your app root, type:

autotest

If everything works out, you should see a few things flash by – I get a error about “Insecure world writable dir” in my home dir. I just ignored that. After that, you should see a test summary in the terminal window, followed by a mumbles popup notificaton. Kick ass!

I was in a cleaning mood today & eventually got to my desk where my PC is at. I think cleaning was waypast due… anyway – it was a photo oppurtunity. Here’s my current setup:

Laptop Specs: IBM T61, Pentium Dual Core Centrino Duo @ 1.83GHz, 1.5gb ram, 50gb hard drive, docking station, Ubuntu Hardy Heron v8.04
Desktop Specs: MSI P35D3 motherboard, Pentium Core 2 Duo @2.66GHz, 3.2gb DDR3-1066 ram, 2x 500gb and 1x 100gb internal hard drives, GeForce 8800 GTS video card with 512mb memory, Ubuntu Hardy Heron v8.04

Desktop setup

Desktop setup

Books that made it to my desk... What's that under my right monitor? Is that a PHP book? hahaha

Top: APC Back-UPS RS 1500, 6 external hard drives (a little over 3 terabytes of storage space), PC painted by my friend Nick, and Laptop.
Left: 22″ Element Flat TV attached to my desktop via HDMI
Right: 22″ Samsung SnycMaster 226bw monitor attached to my laptop via docked vga.

I feel like I have been in a cave for the last 6 months… Well, I sorta have. I’ve been working on a rails project for Epocrates.com for the last 6 months — a type of social network that joins wall street with MDs opted into market research. What a great learning experience & opportunity. It’ll be great one day…

I could only get to chapter 4 today (F.Y.I. A.D.D.4-I) — but it was a nice fresh take on ruby & programming in general. Rather basic & elementary so far, but recommended nonetheless.I never thought of an array as a caterpillar…

Check it out if you have not already!