Robby on Rails: Category Programming

Google Chrome: discuss

Robby Russell — Mon, 01 Sep 2008 21:40:00 -0500

I’m sure that most of you heard the news that Google is releasing a new web browser named Chrome. Their comic for the announcement was very refreshing and entertaining read. Granted… nobody that I know has seen it (as of today)...

For me, I’m really interested in seeing what they’ve done to hopefully improve some of the short-comings of the user experience through their interaction design process. For example, tabs containing their own url/search fields sounds refreshing (I really dislike the hierarchy currently). Also, I’m really looking forward to their dashboard-like default page.

From a web development standpoint, it definitely raises questions about what we’ll be able to do in the coming year(s).

What are your initial thoughts on this? Discuss…

Update: Gary came across this amusing quote from a response by a representative at Microsoft.

“The browser landscape is highly competitive, but people will choose Internet Explorer 8 for the way it puts the services they want right at their fingertips … and, more than any other browsing technology, puts them in control of their personal data on-line,” Hachamovitch said. (read article on CNN)

I’m really not sure what that even means. Don’t we already have our online services at our fingertips? I suspect CNN interviewed the wrong person.. because this person said nothing.

Update #2: Only a PC version available… OSX / Linux are in development. Oh well…

The new RubyURL API

Robby Russell — Sun, 31 Aug 2008 13:55:00 -0500

We’ve just deployed the initial version of an API for RubyURL. It makes it really easy to create RubyURLs and is now open to the public. Should it end up being abused, we’ll consider introducing an API KEY for authenticating and tracking abuse.

In the meantime, you can now start to use the RubyURL API.

For example, the following…


$ curl  -i \ 
        -X POST \
        -H 'Content-Type: application/xml' \
        -d '<link><website_url>http://github.com/robbyrussell</website_url></link>' \
        http://rubyurl.com/api/links  


	...would return the following response.




	I’ll be updating the ShortURL gem in the coming days (unless someone else wants to patch it first wink) to take advantage of new API, versus how it’s currently creating RubyURLs.


	You can see the code & changes for this new API on the RubyURL github site.


	Update with JSON


	I took a little time today to update the API and extend it to support JSON. So… you can now use the RubyURL API to generate RubyURLs via JSON. (see commits)




	Enjoy! If you’re using RubyURL via the new API, I’d love to hear about it. :-)



Flash Message Conductor
Robby Russell — Fri, 29 Aug 2008 16:35:00 -0500
Do you find yourself copying and pasting the same code from Rails application-to-application as new projects start? Our team has a handful of projects in development right now and we notice that some of these reusable components tend to get out of sync when we bounce between projects. So, we’re making an effort to spot these and are creating a handful of plugins so that we can keep them updated between projects. (I’m sure that a lot of you do this as well)


	In an effort to share some of our patterns, we’ll try to release them into the wild for others to use and perhaps if you have better patterns to offer, we’re always interested in improving our approach.


	Introducing Flash Message Conductor


	Over the years, our designers and developers have approached the management of flash messages several different ways. In Rails, the default way to add something to a flash message is to do something like this in your controller.


flash[:message] = "You have successfully signed in to your account."

	What we began doing a while back is to create a few controller helper methods:


add_message( "You have successfully signed in to your account." )
add_notice( "You've Got Mail!" )
add_error( "Oops! Something got fucked up!" )

	Really, nothing too crazy here, just a pattern that our developers have preferred to managing our application’s flash messages.


	Okay, so now for the part of the puzzle that we aimed to make consistent across our projects. Rendering flash messages would usually result in several lines of conditionals in our application layout to check if the flash had any values assigned to it. As we worked with our HTML/CSS designers to define a consistent pattern, we moved our code into a helper for rendering flash messages.


	With Flash Message Conductor, we just need to pop in the following into our application layout.


<%= render_flash_messages %>

	If we had called add_message, it’d render the following:


<div id="flash_messages">
  <p class="message">You have successfully done XYZ...</p>
</div>

	Or, should you have called add_error, it’d render the following:


<div id="flash_messages">
  <p class="error">Oops! Something went bonkers!</p>
</div>

	What we’ve done here is defined a consistent pattern for our designers and developers to follow. We’ll always have a div container that will use a p tag to display the flash messages with a CSS class value that maps to the type of flash message that we’re displaying. This makes it easier for us to reuse the same flash message styling (and tweak if necessary), but we know that it’ll produce the same HTML across our applications.


	Installing Flash Message Conductor


	Like most modern Rails applications, you can install with:



script/plugin install git://github.com/planetargon/flash-message-conductor.git


	Then all of our helper methods will be available to your application. We’ve also included an example CSS file, which you’ll find in the plugin directory.


	Sample output:



Uploaded with plasq’s Skitch!

	Anyhow, we’ve posted the plugin up on GitHub for you all to use, if you’d like to adopt a similar approach. If you have any alternative patterns that has helped your team, do share and I’m looking forward to sharing some more of ours in the near future.


	For more information, visit the Flash Message Conductor plugin on GitHub.


	If anything, hopefully this will inspire those of you who find yourself copying/pasting artifacts from application-to-application to extract that code into it’s own reusable plugin. :-)


RSpec: It Should Behave Like
Robby Russell — Tue, 19 Aug 2008 21:47:00 -0500
I was going through an older project of ours and cleaning up some specs and noticed how often we were doing the same thing in several places. When we started the project, we didn’t get the benefits of shared groups. Now that we have some time to go through and update some of our older specs, I’ve been trying to take advantage of the features currently available in RSpec. One feature that I haven’t seen a lot of mention of by people is shared groups, so I thought I’d take a few minutes to write up a quick intro to using it.


	To pick some low-hanging fruit, let’s take an all-too-familiar method, which you might be familiar with… login_required. Sound familiar? Have you found yourself stubbing login_required over and over throughout your specs?


describe Admin::DohickiesController, 'index' do

  before( :each ) do
    controller.stub!( :login_required )
    Dohicky.should_receive( :paginate ).and_return( Array.new )
    get :index
  end

 ...
end

	If you’re requiring that a user should be logged in when interacting with most of the application (as in the case of an administration section/namespace), you might want to consolidate some of your work into one shared specification group. The basic premise behind this is that you can write a typical describe block and load it into any other spec groups that you need. For example, in our case, we’ll need to stub login_required in several places. We can set this up in one shared group and reference it wherever necessary.


	For example, here is what we’ll start off with.


describe "an admin user is signed in" do
  before( :each ) do
    controller.stub!( :login_required )
  end
end

describe Admin::DohickiesController, 'index' do
  ...

	However, the new describe block isn’t accessible from the block at the bottom of the example… yet. To do this, we just need to pass the option: :shared => true as you’ll see in the following example.


describe "an admin user is signed in", :shared => true do
  before( :each ) do
    controller.stub!( :login_required )
  end
end

	Great, now we can reference it by referring to it with: it_should_behave_like SharedGroupName. In our example above, this would look like:


describe "an admin user is signed in" do
  before( :each ) do
    controller.stub!( :login_required )
  end
end

describe Admin::DohickiesController, 'index' do
  it_should_behave_like "an admin user is signed in"

  before( :each ) do
    Dohicky.should_receive( :paginate ).and_return( Array.new )
    get :index
  end

 ...
end

describe Admin::DohickiesController, 'new' do
  it_should_behave_like "an admin user is signed in"

  before( :each ) do
    @dohicky = mock_model( Dohicky )
    Dohicky.should_receive( :new ).and_return( @dohicky )
    get :new
  end

  ...

	That’s it! Pretty simple, eh? We can now reference this shared group in any describe blocks that we want to. A benefit to this approach is that we can make change the authentication system (say, we decide to switch it entirely and/or even just change method names, set any other prerequisites necessary when an admin is signed in), we’ll have a single place to change in our specs. (tip: you can put these in your spec_helper file)


	You can learn more about it_should_behave_like and other helpful features on the RSpec documentation site.


	If you have any suggestions on better ways of handling things like this, please follow up and share your solutions. I’m always looking to sharpen my tools. :-)


	Update


	In response, Bryan Helmkamp suggests that a better solution is to define a method in our specs like, for example: build_mock_user_and_login. then calling it in our before(:each). So, maybe the approach above isn’t the most ideal method but I did wantt o draw some attention to it_should_behave_like. I suppose that I need a better example.. another post, perhaps? :-)


	Also, Ed Spencer has posted an article titled, DRYing up your CRUD controller RSpecs, which will introduce you mor to it_should_behave_like.


	Thanks for feedback people!


	Related Posts


	
	Be Careful that you don’t Stub your Big Toe
		Spec Your Views
	


Alan Cooper @ Agile2008 slides
Robby Russell — Tue, 12 Aug 2008 18:19:00 -0500
Alan Cooper, author of About Face, has slides from his presentation at Agile 2008 online.


	
	The Wisdom of Experience
	


	If anybody knows if there is video of this talk, please let me know. :-)


	Here are a few skitches from the slideshow.













Expanding Rails Boxcar packages
Robby Russell — Mon, 04 Aug 2008 09:30:00 -0500
If you’re in the market for a new hosting provider for your Ruby on Rails application, you might take a look at the new options for Rails Boxcar. We recently expanded our service offerings into three pricing tiers as well as custom packages for those who need a bit more.


	


	A few things that we’ve recently added support for:


	
	Provide us your SSH key during sign up!
	
	Allows us to keep your server even more secure by avoiding sending passwords over the net
		Other fun features related to this coming soon
	
	
		Auto-configured Nginx w/Mongrel cluster
		Phusion Passenger (mod_rails) support! (for those with mixed-environments)
		Continued development of Boxcar Conductor)
		...more in the works!
	


	The best part is that we can get you up and running with a new Boxcar now for as low as $59/month USD.


	For more information, visit: http://railsboxcar.com


	If you have any questions, don’t hesitate to contact us.


The Art of Delivery, part 2
Robby Russell — Thu, 22 May 2008 13:42:00 -0500
Two years ago, I wrote an article titled, The Art of Delivery. I wanted to post a few updates based on how our process has evolved since then (and continues to).


	Over the past few years, we’ve been fortunate enough to work on quite a diverse collection of projects. This has enabled us to work with many different clients and solicit feedback on our process. This has given us an opportunity to evolve a set of best practices that fulfills the long-term project goals/budgets of our client while making sure that we’re able to maintain a design and development process that is agile.


	As I’ve mentioned in previous posts, our team typically bills work per-iteration on projects rather than per-hour or a flat-bid per-project. Since iterations are bite-sized pieces of the entire project and limited to 1-2 weeks, our teams estimates are much more accurate and we’re able to keep things rolling and on track.


	


	The basic structure of our project looks like this.


	
	A Project has many releases
		A Release has many iterations
		An Iteration has many deliverables
		A Deliverable has many tasks
	


	Before we begin working on an iteration, we outline a set of goals that we want to create solutions for. This process comes out of discussions between our client and us until we agree on what is the highest value/most critical to the success of the project, based on our shared understanding of where we are today. These goals translate into Deliverables, which in a typical iteration might require Interaction Design, Interface Design, or Development. We tend to break our process up into stages so that Interaction Design on Module XYZ would be implemented in a following iteration. This is because it’s unrealistic to expect someone to provide an accurate estimate on how long it’ll take to implement something before you know how people will interact with it.


	Within any given iteration, our team is spread across several sets of deliverables. As a team, we breakdown these deliverables into smaller sets of tasks. It’s our aim to keep tasks smaller than a full days worth of work as it’s much easier to measure progress across the iteration when we can track tasks at a granular level.


	Essentially, tasks are the individual steps needed to achieve these goals. We don’t go out of our way to list each one of those during an estimate process as some tasks take less time than it takes to generate an estimate for them. Each person providing estimates should avoid getting too granular and aim to find a good balance that compliments their workflow.


	Like most things… mileage may vary.


	Through this process, we can get calculate the estimated costs for each deliverable, which then provides us an cost for the entire iteration. In addition to deliverables, we also budget a set of hours/days so that we can be compensated for handling small requests, bug fixes, and project management. It’s important to factor these things into your process.


	In future posts, I’ll discuss how we’re handling this process while working on multiple projects… as that’s where it can chaos can start if you’re not careful. ;-)


	


	How does your team work? As we’re always evolving our process in an effort so that we can be more efficient and speed up our delivery cycle, I’d love to learn from those in the community.


git-svn is a gateway drug
Robby Russell — Thu, 10 Apr 2008 22:28:00 -0500
As we’re migrating away from Subversion to Git, I’m having to learn a lot about git-svn. Andy has posted a few articles on this topic, but I wanted to share a quick tip that I find myself forgetting.


	Working with Subversion branches


	While you’re hopefully already familiar with how great local branches are with Git, you might not know that you can connect local branches to remote branches in your Subversion repository. This allows those of us who are using Git locally to work against Subversion branches.


	I’m going to assume the following:


	
	Your team is using Subversion
		Your team already has a branch that you’re working in
		Your team is following Subversion directory conventions (branches/, tags/, and trunk/)
		You have Git installed (with SVN extensions)
	


	Checkout the Subversion project with Git


	Please visit Andy’s tutorial, Git SVN Workflow, for a more detailed explanation of the following commands.


	First, we’ll initialize your new local Git repository with git-svn.



  git svn init -s http://svn.yourdomain.com/repos/project_name


	Now, you’ll change directories to your new Git repository.



  cd project_name


	Let’s fetch all previous revisions into your local repository¹.



  git svn fetch


	Great, once this is done… you’re master (local) branch is linked to trunk/.


	Mapping a local repository to a remote branch


	Assuming that your team is working in a Subversion branch on the current iteration of work. Our team has a naming convention for branches for each iteration. For example, if we’re in Iteration 18, we’ll write this as ITER-018 everywhere (Basecamp, Lighthouse, Subversion, etc…). At the start of each iteration, we create a new branch with this naming convention.


	For ITER-018, the Subversion branch would be located at:


	
	http://svn.yourdomain.com/repos/project_name/branches/ITER-018
	


	If you were to do a git branch -r, you should see ITER-018 show up in the list. Now, the one thing that wasn’t clear when I first read the git-svn documentation was that you can’t just checkout that branch with one command. In fact, this has tripped me up a few times.


	First, you’ll need to checkout a new local branch. I’ve opted to come up with my own convention for local branches and in this case, I’ll name it iter_018.



  git co -b iter_018


	So, now I’m in the iter_018 branch, which is local. I’m currently still mapped to trunk/, which isn’t what we want. However, all we need to do is reset where Git is currently pointed to. We can run git reset to point this to the ITER-018 branch.



  git reset --hard ITER-018


	That’s it! Now, the local iter_018 branch will point to branches/ITER-018 in your Subversion repository. This will allow you to work with your existing repository branch and still reap the benefits of local Git repositories.


	What about master?


	Good question. The git reset command that you ran will ONLY apply that that individual local branch. So, master is still pointing to trunk/. This will allow you to have several local branches that map to remote branches.


	Next Steps…


	If you’re working with Git already.. great!


	If you’re working in an environment that using Subversion, git svn provides you the ability to start exploring Git without making your entire team switchover. Perhaps your a consultant and working for a client that uses Subversion… no problem!


	We’re still using Subversion for past client projects and are considering GitHub, which just launched (to the public) today for future projects. A few of us are already using GitHub for open source projects.


	Fun.. I just saw the following tweet pass by as I began to wrap up this post.



Uploaded with plasq’s Skitch!

	Check out Rails on GitHub!


	The Gateway Drug… Git reminds me of Cake




	Questions?


	I know that I glossed over a few things, so feel free to post questions and/or tips for others who are looking to dabble with Git.


	¹ You’ll likely have problems if you don’t have a Git authors file specified in your git config.


Tip: Link to Unimplemented
Robby Russell — Thu, 27 Mar 2008 06:10:00 -0500
Throughout our design and development process, we’re working around areas of the site that are not yet implemented but we also want to be able to allow our clients to demo their application. In an effort to manage their expectations, we need to be careful about what we link to. If a page/widget isn’t ready to be demo’d yet, we should avoid providing pathways to get interact with or navigate there. However, when we’re implementing HTML/CSS for pages, it’s sometimes makes sense to not hide certain things on the screen.


	For example, let’s suppose that you’re working on the primary navigation of an application. You know what the other sections are going to be, but you’ve only implemented a few of them so far. Your HTML/CSS person is working on the design for the navigation and wants to have them be proper links… even to pages that don’t yet exist.


	One option, which is quite common, is to provide a link with href="#". This works to some extent, but when people click on things, they naturally expect something to happen in response.


	This approach doesn’t mesh well with our team as we don’t really want to field any questions like, “the navigation links are all broken. Nothing happens!”


	So, a pattern that we’ve been using for a while is to trigger a javascript alert for every link within an implemented area that is linking to something that isn’t yet implemented.


	Let’s take a really basic javascript function like:



# public/javascripts/application.js
function unimplemented() {
  alert("NOTICE\n\nThis feature is not implemented yet. Please check back again soon!");
}


	This allows us to do the following:



  <a href="javascript:unimplemented();">link text</a>


	When someone clicks the link, they’ll see a typical javascript alert message. This informs our clients/beta testers that we’re paying attention to what works and what doesn’t.



Uploaded with plasq’s Skitch!

	Let’s take it a step further and push this into a view helper.



# app/helpers/application_helper.rb
def link_to_unimplemented( link_text, *args )
  link_to_function( link_text, 'unimplemented()', *args)
end


	Now, we’re able to use link_to_unimplemented and pass any arguments that you’d pass to the default link_to view helper.



<%= link_to_unimplemented( 'link text', { :class => 'link_class_name' } ) -%>


	Now our web designers can go about their work and use this helper as necessary.


	An nice benefit for doing this is that we have a pattern that we follow so that we can rely upon to make sure that we don’t forget anything. This is the equivalent of adding @TODO@s throughout our code base.


	If we search through app/views for ‘link_to_unimplemented’ we should be able to prevent missing any broken links. In the next screenshot, I’m using grep with colorized matches.



Uploaded with plasq’s Skitch! 

	As you can see, we have something left to implement in that area of the application. :-)


	This has been one of those lightweight patterns that we’ve been able to adopt and it’s definitely helped manage the expectations of our clients throughout our development process.


	I’d love to hear your thoughts on this. How does your team handle things like this?


	Related Posts


	
	Designers, Developers, and the x_ Factor
		Spice up your Terminal with colored grep pattern results
	


Managing Required Gems on Rails Projects
Robby Russell — Wed, 26 Mar 2008 22:27:00 -0500
We’re starting a new project and I’m finding myself adding things to the code base that we’ve done in the past… hence the last few posts. As we’re doing this, I’d like to highlight some of the little things that we do on each project to maintain some consistency and in that process reach out to the community for alternative approaches.


	I’m intrigued by the vendor everything concept, but we haven’t yet adopted this on any of our projects (yet).


	What we have been doing is to maintain a REQUIRED_GEMS file in the root directory of our Rails application.


	For example:



$ cat REQUIRED_GEMS

actionmailer
actionpack
actionwebservice
activerecord
activesupport
cgi_multipart_eof_fix
daemons
fastercsv
fastthread
feedtools
gem_plugin
image_science
mongrel
mongrel_cluster
mysql
rails
rake
RedCloth
Ruby-MemCache
soap4r
uuidtools


	Everybody on the team (designers/developers) knows to look here to make sure they have everything installed when beginning to work on the application.


	This has worked fairly well from project to project but since we’re starting a new project, I’m curious if anybody has some better ways to approach this. Should we look more seriously at the vendor everything approach or are there any alternative approaches?


Managing SEO-friendly HTML Titles with Rails
Robby Russell — Wed, 26 Mar 2008 16:41:00 -0500
I’ve seen this come up a few times in the #rubyonrails IRC channel and figured that I’d post a quick entry for future reference.


	Problem: HTML titles


	You want to have a clean way to manage the titles on your HTML pages.



  <html>
    <head>
      <title>Robby on Rails &mdash; Article Title Goes Here</title>
    </head>
    <body>
      ...


	Possible Solution(s):


	Since the <title> tag is usually declared in your layout, you need to be able to dynamically update this information from almost every action in your application.


	Here are a few ways that I’ve seen this handled.


	
	Use a instance variable, which would have a default value and you could override it in any controller action
		Use the content_for method to manage it.
	


	Let’s take a few minutes to look at these two approaches.


	Instance Variable


	With the instance variable, you might end up with something like:



  # app/views/layouts/application.html.erb
  <title>Robby on Rails &mdash; <%= @html_title || 'Default text here...' -%></title>


	Then in a controller action…



  # app/controllers/articles_controller.rb
  def show
    # ...
    @html_title = @article.title
  end


	So, that’s one way to handle it and is probably a more common way.


	The content_for helper method approach


	This solution is very similar (and underneath uses an instance variable).


	We’ll use the content_for and a little yield action.



  # app/views/layouts/application.html.erb
  <title>Robby on Rails <%= (html_title = yield :html_title) ? html_title : '&mdash; Default text here...' %></title>


	Then we’ll create a helper method.



  # app/helpers/application_helper.rb
  def set_html_title(str="")
    unless str.blank?
      content_for :html_title do
       "&mdash; #{str} " 
      end
    end
  end  


	Now, instead of defining the HTML <title> value in the controllers, we’ll just toss this into our html.erb files as necessary.



  <% set_html_title(@article.name) -%>
  ... rest of view


	..and that’s pretty much it.


	Which is the better solution?


	This is where we’ll not find a lot of consensus amongst people. I’m a fan of the content_for-based approach and defining the title in views rather than in controller actions. I’m an advocate of skinny controllers and while I’m not a big fan of messy views, I believe that there is less overhead in managing this within the View-world.


	I’d love to hear your thoughts on this. Perhaps you have a more eloquent for managing things like this? Do share. :-)


Things (in the Rails world) You Don't Yet Understand
Robby Russell — Tue, 25 Mar 2008 10:12:00 -0500
This is inspired by a recent post by Seth Godin titled, Things you don’t understand, where he shared a list of things that he probably could understand if he put your mind to it, but doesn’t. I decided to post a list of five (5) things in response within the context of Ruby/Rails.


	I’m really interested in various things but am really unable to prioritize them high enough to spend the time to understand them.


	
	RSpec User Stories
		Using Selenium with RSpec
		JQuery (Graeme speaks highly of it)
		JSSpec (BDD for Javascript)
		Using the Google Charts API with Rails
	


	What about you? What’s your list of things that you’d like to understand more about?


DRY(a): Year After Year
Robby Russell — Mon, 24 Mar 2008 22:05:00 -0500
I’m guilty of it. Many of you are likely guilty of it… and I know that several customers of our Rails Code Audit and Review service are guilty of it.


	How many times have you realized (after a few months has passed) that your Copyright date/year on your web site was no longer current?


	How many of you had the same problem last year? The year before?


	Let me share some advice with you all… DRY (a)!


	Don’t Repeat Yourself (again)!


	This is really a simple problem to fix but when we’re busy tackling bigger problems… little things like this slip by. Don’t worry, you’re not the only one who was reminded by a colleague three months into the year that you forgot to update this.


	On client projects, we have a handful of helpers that we drop into the application. We’re starting to extract more of these into plugins and will be releasing those as time permits. It just happened that I found myself looking at yet-another Rails code base this afternoon that was showing 2007 in the footer. An easily forgivable offense.. but if you’re going to go in there and change it (again), take a moment to do the right thing. ;-)


	Our solution at Planet Argon on client projects is to create a basic view helper that renders the current year. This allows us to do the following.



  <div id="footer">
    &copy; Copyright <%= current_year -%>. All Rights Reserved.
  </div>


	The helper code looks like:



  # add to application_helper.rb
  module ApplicationHelper
    def current_year
      Time.now.strftime('%Y')
    end
  end


	Voila. Not rocket science.. is it?


	Guess what? I’m getting really tired of adding this to every Rails project that I touch. So, I bottled this little gem into a new Rails plugin that we’ll just add to future projects.


	Introducing Year after Year


	This is really the smallest plugin that I could put together (and it includes specs!)


	What does it provide you?


	YearAfterYear will provide you a helper that will render the current year (dynamically)! That’s right… just add the plugin to your Rails application and you too can enjoy New Years 2009 without having to have a deployment ready with a one line change from 2008 to 2009!


	To use.. add the following to any view from within Ruby on Rails.



  <%= current_year -%>


	Installation


	As I’m using git, you’ll need to grab this and put it into vendor/plugins. That’s it!


	You can grab it on GitHub!


	
	http://github.com/robbyrussell/year_after_year/
		Bugs / Feature Requests here
	


	Happy New Years (8+ months early)!


	Just a friendly reminder to not forget the small stuff… because your visitors will notice! ;-)


	Updates…


	I got a few requests for this to also provide a range of years for people who like to do: 2005-2007. So this is now provided as well.


	year_range(start_year)


Example:

  <%= year_range(2005) %> # => 2005-2008



Learning Git without getting your SVN feet wet
Robby Russell — Tue, 11 Mar 2008 01:59:00 -0500
Our team has been migrating towards using Git as our primary SCM. We have way too many Subversion-based projects and repositories to just do a clean switch over and not everybody on the team has had time to start playing with it. Baby-steps…


	So, for those of us who want to use it day-to-day, we’re using git-svn.


	Andy Delcambre has posted the first in a series of blog articles to help you pick up on using Git on Subversion-based projects. Check out his article, Git SVN workflow to get up to speed.


	Also, if you’re on OSX and using Git… check out Justin Palmer’s new project, GitNub, which describes itself as, “a Gitk-like application written in RubyCocoa that looks like it belongs on a Mac.” This looks promising. :-)


Launch your own RubyURL
Robby Russell — Sat, 01 Mar 2008 18:31:00 -0600
A few weeks ago, I moved RubyURL from subversion to git. During that process, I decided to use my invite to GitHub and have decided to go ahead and open up the source code.


	It’s currently a whopping 92 LOC with a 1:2.5 code to spec ratio. (I had a goal to keep is below 100 LOC)


	
	RubyURL on GitHub: http://github.com/robbyrussell/rubyurl
		Public Clone URL: git://github.com/robbyrussell/rubyurl.git
	


	Feel free to grab it and help contribute. This has served almost 14 million redirects since August 2007 and is running on a Rails Boxcar.


	To grab it with git.. run: git clone git://github.com/robbyrussell/rubyurl.git.


	Feel free to submit tickets to the Rubyurl ticket system.


	
	http://planetargon.lighthouseapp.com/projects/4059-rubyurl
	


	Enjoy!


	UPDATE Ryan McGeary was kind enough to be the first person to help track down a bug and submit patches. :-)


ShortURL 0.8.4 released and gets a new mainainer... me!
Robby Russell — Sun, 06 Jan 2008 18:49:00 -0600
Earlier today, Vincent Foley was kind enough to hand over maitenance of the the ShortURL project on RubyForge to me. He first released it back in 2005, which I blogged about as RubyURL was the first shortening service that it supported (and is the default). Unfortunately, the release of RubyURL 2.0 broke backwards compatibility and Vincent wasn’t maintaining it anymore. So, earlier, I decided to patch this and got a new version released that now works with the current RubyURL site.


	While working on the code, I decided to extend the compatible services to include moourl and urlTea.


	These updates are available in ShortURL version 0.8.4.


	Install the ShortURL gem


	Installation is a snap… (like 99.7% of rubygems…)



  ~ > sudo gem install shorturl                                                                                                                                                                                                           Password:

  Successfully installed shorturl-0.8.4
  1 gem installed
  Installing ri documentation for shorturl-0.8.4...
  Installing RDoc documentation for shorturl-0.8.4.  


	Using ShortURL


	The ShortURL gem provides the ShortURL library, which you can use from any Ruby application.


	Using the ShortURL library



  ~ > irb                                                                                                                                                                                                                           
  irb(main):001:0> require 'rubygems'
  => true
  irb(main):002:0> require 'shorturl'
  => true
  irb(main):003:0> ShortURL.shorten( 'http://www.istwitterdown.com' )
  => "http://rubyurl.com/P9w" 


	As you can see…it’s really straight forward.


	Let’s try it with a few other services.



irb(main):004:0> ShortURL.shorten( 'http://www.istwitterdown.com', :moourl )
=> "http://moourl.com/fvoky" 
irb(main):005:0> ShortURL.shorten( 'http://www.istwitterdown.com', :tinyurl )
=> "http://tinyurl.com/2t3qmh" 


	Using the shorturl command-line tool


	Many people don’t know that ShortURL provides a command-line tool, which you can use after installing the gem.



  ~ > shorturl http://istwitterdown.com                                                                                                                                                                                               
  http://rubyurl.com/Lwk


	If you’d like to see more services provided than the ones listed here, please submit feature requests and/or patches on the rubyforge project.


	
	http://rubyforge.org/projects/shorturl/
	


	ShortURL Documentation


	To see the latest documentation for the project, please visit:


	
	http://rubyforge.org/projects/shorturl/
	


	My favorite part about this? My rbot plugin for RubyURL works again!



Uploaded with plasq’s Skitch!

	Happy URL-shortening!


Advanced Mathematics and Programming
Robby Russell — Tue, 01 Jan 2008 14:40:00 -0600
First of all, Happy New Year!


	The other day I received an email from a friend where she asked me if I thought that  having excellent math skills were important in a programmers career. I’ve heard this question asked before and while I thought that might have been the case when I was a lot younger (when I had zero plans to go into the IT world)... I’ve not seen this to be true. My response to her was that it really depended on the types of programming work that one might want to go into. There are definitely programming jobs that require extremely advanced mathematical skills, but I’d guess that many, if not most, don’t really have that sort of prerequisite.


	


	So, as I was saying. I think it really depends. It depends on what sort of programming you’re interested in pursuing. In general, when we’re looking to hire someone at Planet Argon, we’re looking for people with good research and problem solving skills. Programming languages are tools to help solve problems and build things. So, while math skills are useful, they aren’t likely going to make or break a developer.


	Like any career, it should be something that you’re passionate about.


	I’m curious. As programmers… how would you respond to the following question?


	
		“Should an advanced knowledge of mathematics be a prerequisite in pursuing a career in programming?”
	


	I can only answer the question from my own perspective and would like to share some others. Thanks!


Embracing Chaos, part 1
Robby Russell — Mon, 17 Dec 2007 22:21:00 -0600
Consider this part one of several posts on my thoughts of the art of embracing chaos.


	Don’t let the books fool you. The construction of custom software is an unmastered and volatile cesspool of chaos. I don’t adhere to the belief that there is a perfect methodology or process that will work for every project… as I’m sure many of you don’t.


	


	Unlike bowling, you’ll never achieve a perfect score. Even in bowling, It’s unlikely that anybody will learn how to bowl a perfect score and do so on every game for the rest of their career.


	You’ll never meet every expectation that a client has on every project.


	You’ll never meet every expectation that a user has when they interact with your application.


	Expectations are an interesting thing.


	Your project might get widely adopted and embraced, but you’re still trying to control chaos.


	


	It’s chaos. Pure chaos¹.


	So, why do we bother? Why do we try so hard when the odds aren’t in our favor?


	To be continued…


	Related Posts:


	
	Embracing Failure
		Don’t Over Promise
	


	¹ Chaos Theory, Wikipedia


Get to Know a Gem: Rak
Robby Russell — Tue, 11 Dec 2007 11:10:00 -0600
A few months ago, I posted about an article that showed you how to colorize your grep search results. Since then, I’ve heard people talking about ack, which describes itself as…


	
		“a tool like grep, aimed at programmers with large trees of heterogeneous source code.”
	


	It’s written in Perl, which is fine and dandy… but before I installed it, I heard that there was a Ruby version named rak, which describes itself as…


	
		“a grep replacement in pure Ruby. It accepts Ruby syntax regular expressions and automatically recurses directories, skipping .svn/, .cvs/, pkg/ and more things you don’t care about. “
	


	Sounds great. Let’s see what this thing can do.


	Installing rak


	Daniel Lucraft, the author of rak, was kind enough to package it up as a Rubygem. So, all we have to do is install it via gem install rak.



   > sudo gem install rak                                                                                                                                                                                                     
  Password:
  Bulk updating Gem source index for: http://gems.rubyforge.org
  Successfully installed rak-0.8.0
  Installing ri documentation for rak-0.8.0...
  Installing RDoc documentation for rak-0.8.0...
  ~ >


	Great, let’s move on.


	Using rak


	Now that it’s installed, we can use Rak by typing rak from the command line. You’d typically want to run this from within the root of your application.


	For example, basic usage would look like the following.


$ rak search-pattern

	In my first test, I ran rak README.


	


	Immediately, I see a greater advantage to rak over using grep and that’s because it’s giving me line numbers for free, which takes remembering a few extra options with grep.


	Like grep, we can specify a specific path to search with. For example, we use a view helper named link_to_unimplemented to help us track actions that aren’t implemented yet. Looking at a current project, I can run rak link_to_unimplemented app/views and produce the following results.


	


	I’m going to keep playing with it, but wanted to help get the word out. If you have any tips on using it, please share them in the comments. :-)


That Checkbox Needs a Label
Robby Russell — Sun, 02 Dec 2007 00:43:00 -0600
As a user of many web applications, I often find myself noticing little things that slow me down. One such thing is the use of checkboxes in web forms. It’s not the problem of checkboxes itself, it’s the face that checkboxes require the user to really focus their attention to a fairly small box on the page and perform a click inside. If you’re filling out a form really quickly, it’s almost guaranteed that you’ll take advantage of you your tab key to get through each field quickly. Sometimes there are select boxes, which require the user to make selections with their mouse. Checkboxes drive me crazy because it requires more time to position the cursor and move on.


	So, when I see a form like this, I don’t see it being very quick to interact with.


	


	While I’m not in love with the date selection interface here, my bigger pain has been the checkbox in the form. Why? Because they forgot to use the <label for=""> HTML tag.


	What’s the problem? Well, I don’t have the convenience of clicking on the label text, which would toggle the corresponding checkbox.


	


	I know, many of you know all about this… but I run into this problem everywhere. This is an accessibility issue for people and really just increases the chances for a frustrating user experience. When you use the label tag properly… it will provide a larger amount of the screen for people to click, which reduces the chance of not clicking in the right spot. The label tag was designed with this in mind so that people could click close enough to trigger the desired action.


	Here is an example of where it becomes really useful.


	


	So, the lesson? Please remember to use the label for tag. :-)



<input type="checkbox" id="remember_me" name="remember_me" value="true" />
<label for="remember_me">Remember info?</label>  


	This is an easy thing to forget when building web applications. We’ve forgot and I’m sure you have too. I just wanted to point it out though because I see this happen so much… even in new sites.


	Perhaps you run into similar problems with web applications that can be fixed with just a little more HTML. Care to share your experiences?


	For more information, read Labeling form elements  from the Dive Into Accessibility site.


Rolling up my Sleeves, continued
Robby Russell — Tue, 27 Nov 2007 12:33:00 -0600
It’s been about a year and a half since I wrote about my wrist pains that would often occur at work, which was being caused by something I bet many of us deal with from time to time… Repetitive Strain Injury. So, I’ve been wearing these gloves when I’m at work on my normal Apple keyboard. I knew that they helped to some degree because on the days that I forgot them, my wrists would begin to hurt after a hour or two of coding/writing emails. Not much fun.


	A few months ago, I attempted to start typing with Dvorak, which started off with requiring myself to do it for about three hours each morning to start the day and then switching back. After about a week and a half, I forgot to continue doing it. The Dvorak keyboard sits next to my desk… whispering to me, “play with me”... but I haven’t had time to get back into it.


	So, the strain continues from time to time. Over the course of a few months, I began to notice that most of the strain seemed to be in my right wrist and I started to wonder if the mouse movements were a bigger culprit than the keyboard itself. So, I spoke to a guy at Macforce (a cool and local Apple dealer) about the mouse pad that he was using. He said that it really helped him out and so I bought myself one.


	


	It’s a Belkin WaveRest™ Gel Mouse Pad and cost me less than $30 USD. It’s been a few weeks and I’ve noticed that I can go almost the entire day without the gloves that I wore before. So, I think that there is still some strain occurring, but a lot less than before. So, I’m hoping to give Dvorak another shot and hope that combo helps alleviate a lot of pain that I’ve been experiencing at work.


	If you’re experiencing wrist pains and it’s focused on the hand that you use your mouse with, you might consider something like this to help out.


	I’m sure that I’m not the only one that has/is experienced motion strain at the computer.. so, what has been your experience and have you  had any success making improvements to your work space to help?


Master/Slave Databases with Ruby on Rails
Robby Russell — Thu, 15 Nov 2007 16:02:00 -0600
Not terribly long ago, I announced Active Delegate, which was a really lightweight plugin that I developed to allow models to talk to multiple databases for specific methods. The plugin worked great for really simple situations, like individual models.. but when it came time to test with associations it fell apart. I haven’t had a chance to work on any updates and knew that it was going to take more work to get it going.


	Earlier this week, we helped one of our bigger clients launch their new web site¹. For the deployment, we needed to send all writes to a master database and a reads to slaves (initial deployment is talking to almost 10 slaves spread around the globe!). We needed something to get integrated quickly and decided to ditch Active Delegate for the time being and began looking at the following options.


	I spoke with Rick Olson² and he pointed me to a new plugin that he hasn’t really released yet. So, I’m going to do him a favor and announce it for him. Of course… I got his permission first… ;-)


	Announcing Masochism!


	Masochism³ is a new plugin for Ruby on Rails that allows you to delegate all writes to a master database and reads to a slave database. The configuration process is just a few lines in your environment file and the plugin takes care of the rest.


	Installing Masochism


	With piston, you can import Masochism with:



  $ cd vendor/plugins
  $ piston import http://ar-code.svn.engineyard.com/plugins/masochism/


	
	To learn more about piston, read Every Second Counts with a Piston in your trunk
	


	You can also install it with the old-fashioned way:



  $ ./script/plugin install -x http://ar-code.svn.engineyard.com/plugins/masochism/


	Configuring Masochism


	The first thing that you’ll need to do is add another database connection in config/database.yml for master_database. By default, Masochism expects you to have a production database, which will be the read-only/slave database. The master_database will be the connection details for your (you guessed it…) master database.



# config/database.yml  
production:
  database: masochism_slave_database
  adapter: postgresql
  host: slavedb1.hostname.tld
  ...

master_database:
  database: masochism_master_database
  adapter: postgresql
  host: masterdb.hostname.tld
  ...


	The idea here is that replication will be handled elsewhere and your application can reap the benefits of talking to the slave database for all of it’s read-only operations and let the master database(s) spend their time writing data.


	The next step is to set this up in your environment file. In our scenario, this was config/environments/production.rb.




# Add this to config/environments/production.rb
config.after_initialize do 
  ActiveReload::ConnectionProxy.setup!    
end



	Voila, you should be good to go now. As I mentioned, we’ve only been using this for this past week and we’ve had to address a few problems that the initial version of the plugin didn’t address. One of our developers, Andy Delcambre, just posted an article to show how we had a problem with using ActiveRecord observers and masochism, which we’re sending over a patch for now.


	As we continue to monitor how this solution works, we’ll report any findings on our blog. In the meantime, I’d be interested in knowing what you’re using to solve this problem. :-)


	¹ Contiki, a cool travel company we’re working with


	² Rick just moved to Portland… welcome to stump town!


	³ The Masochism plugin README


Chad Fowler's Dirty Little Secret?
Robby Russell — Sat, 06 Oct 2007 15:00:00 -0500
I saw this photo of the Microsoft team from 1978 on Anselm’s flickr and thought, “Hmm, that looks like Chad Fowler!”


	


	Could this be Chad Fowler’s dirty little secret?..


	


	Happy Saturday!


Spice up your Terminal with colored grep pattern results
Robby Russell — Sat, 06 Oct 2007 12:43:00 -0500
Earlier, I came across a post by Garry Dolley, which he shows how to acheive colorized grep matches in bash. I recall having color matches when I used to use Linux on a daily basis as my primary work environment, but haven’t gotten around to setting this up on my MacBook, which is where I do almost all of my development work.


	Before


	If you don’t already have colors, a grep in your terminal might look something like the following screenshot.


	


	While, I have a very small output here, this gets much crazier when you’re using egrep across an entire project. It’s hard to scan through all of the results for the inline pattern matches.


	So, taking Garry’s suggestion (for bash), I did something similar with my favorite shell, Z shell.


	Add the following to your ~/.zshrc file to begin experimenting with the colors.



  export GREP_OPTIONS='--color=auto' 
  export GREP_COLOR='1;36'


	After


	With the new variables defined in my .zshrc, I can now start to see colors showing up in my grep results.


	


	Pretty cool, huh?


	Variants


	To save you the trouble of trying tons of combinations yourself, which I suspect you’ll do anyways, here are some other variants.


	Blinking


	If you change the first number in GREP_COLOR to 5, you’re matches will blink!


	You’ll have to experiment with this yourself as I’m not going to make a video for you. ;-)



  export GREP_COLOR='5;35'


	Inverted Colors


	You can also invert the colors so that the background color changes on your pattern matches.


	For example:


	


	To achieve this, you can set the first number in GREP_COLOR to 7.


	...and so much more


	I decided to write a quick and ugly ruby script to iterate through the color combinations that I was trying.


	


	Anyhow, I’ll leave you on that note. If you figure out how to do any other fun things with grep colors, do let me know. :-)


PLANET ARGON is seeking fresh talent... could it be you?
Robby Russell — Thu, 04 Oct 2007 10:10:00 -0500
My blog has been fairly quiet lately because our team has been busy helping push a few big client projects out the door. We’ll be posting announcements about those launches on the PLANET ARGON Blog soon, so stay-tuned there!


	We’ve been growing the design-side of our team lately, but we’re also still seeking some more Rails-talent in Portland, OR. If you’re in Portland or interested in moving here¹, you should introduce yourself to our team. We’re looking for people to work on-site in Portland, so any remote candidates will be turned away… we’re moving into a shiny and new office space in downtown and are looking for another developer to join our Design and Development team.


	
you’ll fit in really well if you’re into outdoor activities… ;-)


	We’re seeking mid-level Ruby on Rails developers that can pick things up quickly. Having some experience with RSpec will go along way with us. Ideal candidates would have great communication skills and be able to work in a fast-paced environment that places a huge emphasis on collaboration between designers and developers (let’s not forget to mention our clients). Bring what you already know and learn the rest with us.


	
While everyone might have Wii’s in the office, we’ve taken it to the next level with Speed Stacking! :-p


	To apply, send an email to af22+8509@c1.catchthebest.com,


	Side note: We’re giving Catch the Best a whirl to review job candidates. If you’re hiring people, you might consider giving it a try.


	¹ Everybody is moving to Portland… ;-)


Edge Rails Documentation: Revisited
Robby Russell — Wed, 26 Sep 2007 08:34:00 -0500
This question, “where can I find documentation for Edge Rails?” still comes up quite often on mailing lists, IRC, and other places. I just wanted to point out a few resources for you.


	In March 2006, our team announced that we’d be updating a RDOC site a few times a day as the Rails project gets commits.


	You can still access the PLANET ARGON Edge Rails documentation here:


	
	http://edgedocs.planetargon.org
	


	Caboose also has some Edge Rails documentation here:


	
	http://caboo.se/doc.html
	


	If you’re aware of any other online resources for Edge Rails documentation, please let me know.


Rails Development Performance Tip - dev_mode_performance_fixes
Robby Russell — Tue, 28 Aug 2007 21:57:00 -0500
When you’re running a Rails application in development mode, you might notice that it takes a little longer for requests to get processed and this is somewhat intentional as the framework is was designed to allow you to run the application and make live changes to it. This way you can do some basic functional tests from your web browser, work on HTML/CSS changes, or anything else that might need to be done in development mode.


	Anyhow, this can be slow from time to time and if you’ve done much Ajax work, you might be familiar with how slow this can feel when performing some basic tasks. Well, thanks to Josh Goebel, we can speed up things with a new plugin he just released.


	To install via piston:


cd vendor/plugins; piston import http://svn.techno-weenie.net/projects/plugins/dev_mode_performance_fixes/

	To install via script/plugin:


./script/plugin install http://svn.techno-weenie.net/projects/plugins/dev_mode_performance_fixes/

	Josh has posted some benchmarks and in my totally basic tests… shows about four times (4x) speed improvement for reqs/sec!


	How does it work? From what I can tell, it works somewhat like autotest, in that keeps things cached and when it sees files modified, it re-caches the changes. He’s made it so that the stack doesn’t need to reload for each request, which is quite slow.


	Since it’s development-mode only, I’d encourage you to install it and give it a whirl.


	Have Fun!


Subscribe to Basecamp RSS Feeds in Google Reader
Robby Russell — Fri, 17 Aug 2007 15:42:00 -0500
Yesterday afternoon, we were helping our newest employee, Paige Saez, get setup with new accounts across all of our applications. She uses Google Reader and couldn’t understand why her Basecamp RSS wasn’t working in it. We explained that Google doesn’t provide any way to subscribe to authenticated feeds (yet)... so it wasn’t something she could do. (I still use NetNewsWire because of this problem…)


	During the discussion, I said that it probably wouldn’t take much effort to build a proxy for an authenticated feed… and Andy said he’d give it a shot.


	10 minutes later… he had an initial version of a RSS proxy application, written in Ruby.


	15 minutes after that, we had it up and running on a private server for all of us at PLANET ARGON to begin using.


	...and here is the proof!


	


	Wee! Authenticated Basecamp RSS feeds in Google reader. It even works with the openid authentication.


	You can grab the code from Andy’s blog post and finally make the switch off of desktop RSS readers to Google Reader, because you know you want to. ;-)


	Thanks Andy!


RubyURL: new design and code base
Robby Russell — Wed, 08 Aug 2007 08:58:00 -0500
Yesterday evening, I deployed the new version of RubyURL. This was a collaborative effort between Chris Griffin and I, which we’re happy to finally push live.


	There are a few things that we’re going to push out in near future, such as an API and a new RubyGem.


	


	Chris volunteered to work on the new design and I did most of the programming in Ruby on Rails. When we worked on this, we really wanted to keep the process as simple as possible, despite some of the problems that the site has been having.


	In the end, we have a Rails application that is only 85 lines of code and has a 1:2.3 code-to-spec ratio. I wanted to keep it under 100 lines of code. This means that there is some breathing room for further development.


	We also tried out a beta account that I was given for RoundHaus for Subversion hosting. We had a really good experience using their service and were impressed by the plethora of useful features that came with the repository, such as continuous integration, rcov/code coverage stats, and twitter integration!.


	If you find a bug, be sure to submit a ticket on the RubyURL bug tracker.


	On a side note, we deployed this on a brand new Rails Boxcar, our new hosting solution that will be launched in the very near future. ;-)


Rails Business: "Weekly" Review #3
Robby Russell — Sun, 05 Aug 2007 10:37:00 -0500
It’s been about six weeks since the last Rails Business “Weekly” Review on here, so perhaps it’s worth changing the name to cut me some slack on not being consistent. ;-)


	Since the last post, we’ve gone from around 400 members to 555 as of this morning. We’ve had 562 messages as well, so there hasn’t been a shortage of discussions taking place. I’d like to take a few moments to highlight some of the discussions that have taken place and encourage you all to consider participating, if you’re not already.


	Licensing and Client Agreements


	Tim Case writes,


“My client sent me this agreement drawn up from their lawyer that
included the following:



(c)     the Contractor shall not bundle with or incorporate into any Work
Product any third-party products, ideas, processes, software, codes,
data, techniques, names, images, or other items or properties without
the express, written prior approval of the Company;” 


	Tim then goes on to ask how his applies to using Ruby on Rails, which as a MIT license and how other consultancies are handling these types of situations. Follow the discussion…


	Escrow


	Gustin writes, “Does anyone have any escrow experience, legal and cost? I am dealing with a client that got burned bad and we are reducing their fear with escrow on the first two iterations.”


	Follow the discussion…


	Project Planning tools


	Mike Pence writes, “So, I used to use MS Project for the composition of those dreaded Gantt charts, but it has been a few years since I had to be so formal. Anything new and exciting – and more robust than Basecamp – happening in the world of project planning software?”


	Follow the discussion…


	Not long after, Jim Mulholland started a new thread on the same topic and brought up the open source application, redMine. Follow this discussion…


	Ruby on Rails versus .NET


	Michael Breen asked a big question on the list, which has sparked an going discussion about the benefits of using Rails versus .NET (and other platforms).


	
		“A couple of months ago I decided to stop actively pursuing .NET gigs to focus on Rails. Several of my existing .NET clients have learned of this through the grapevine and have contacted me to discuss.”
	


	Follow the discussion…


	Three things Tim’s learned from Freelancing Rails


	Tim Case shared his experience of freelancing with Ruby on Rails and highlights three things that he’s learned.


	
	The non-code business aspect of Freelancing is demanding. 
		It takes 10 hours to bill 6 to 8.
		Figuring out your rate is hard.
	


	Read the rest of Tim’s observations and the discussion the followed.


	Client issue tracking and documentation


	Jeff Judge writes, “Hello all! I was curious to here how people are handling client issue tracking and documentation.”


	Several applications were mentioned for handling issue tracking and the general consensus was that there was still a lot to be desired that current options didn’t provide. Be sure to follow the discussions…


	Join the Community


	These were just a small handfull of the discussions that have taken place over the past several weeks. If you’re an aspiring Rails freelancer or business owner, be sure to join the community and share your experiences and learn from other members of the community that are willing to share theirs.


	Until next time, have fun!