def comment_fields(f,course,discussion,comment)
  render :partial => 'comments/fields',
    :locals => { 
      :f => f,
      :course => course,
      :discussion => discussion,
      :comment => comment }
end

In these helpers you’re typing out each variable name 3 times, once in the function definition and twice in the locals hash. Wouldn’t it be great if you only had to type the name of the variables in the definition and have the local hash generated automatically? Well we’ve created a nifty helper called locals that will do just that. It works like this:

def comment_fields(f,course,discussion,comment)
  render :partial => 'comments/fields',
    :locals => locals(binding)
end

The binding object is built-in to Ruby and allows you to access a list of variable names in the local scope. The locals helper will use this object to generate a hash of variables that you can pass to the render function.

You will need to put this function in your application_helper.rb:

def locals(helper_binding,*locals)
  options = locals.extract_options!
  result = {}
  vars = eval("local_variables",helper_binding)
  for var in vars
    result[var.to_sym] = eval("#{var}",helper_binding)
  end
  result.merge(options)
end

locals(binding) will grab all the local variables that exist at the time it’s evaluated (not just the variables that are in the function definition). You can pass a hash to locals to specify additional variables to pass.

So for example this code:

def comment_fields(f,course,discussion,comment)
  user = comment.user
  render :partial => 'comments/fields',
    :locals => locals(binding,
      :comment_count => discussion.comments.length)
end

Is the same as:

def comment_fields(f,course,discussion,comment)
  render :partial => 'comments/fields',
    :locals => { 
      :user => comment.user,
      :f => f,
      :course => course,
      :discussion => discussion,
      :comment => comment,
      :comment_count => discussion.comments.length }
end

  def mine?(user)
    if current_user == user
      t('users.show.your')
    else
      "#{user.name}'s"
    end
  end

The if/else takes up 5 lines but the statements are short enough to be put on one line:

  def mine?(user)
    current_user == user ? t('users.show.your') : "#{user.name}'s"
  end

Usually I will write out the entire if/else statement then change it to single line form afterwards once I see how short it is. To save myself some time I created two Textmate bundle commands to help do this. The first will take a 5 line if/else (such as the one in the mine? function above) and turn it into a single line statement. This requires you select the entire if/else then press the hotkey ⌥⌘T.

The second will do the reverse operation, turning a ternary operator statement into an if/else. The hotkey for the reverse function is ⌃⌥⌘T and will grab the entire current line so you don’t need to select the statement first.

Download the Textmate Bundle commands here.

Oh, let us not forget the solution:

"This is a test".replace(/test/,'an explosion')

You want to get hired as web-developer? Don’t show a paper that suggest results, give them something to chew, if it tastes good, they’ll want more.

I picked up my Swingline red stapler. Why did I buy it?, how often do I use it and why do I need it? I am never stapling and I’m not going to staple anything in the next year.

I have a pile of papers on my desk that I’m holding onto because I need to do my taxes. The pile looks daunting, but if I were to throw out the junk in that pile, doing my taxes would seem much easier.

I need to frequently travel, and I have a pile of clothes. I don’t wear half of them but when it comes to packing, the pile looks daunting, if I were to throw out the clothes I don’t wear my packing would seem much easier.

I have a iMac that only gets used to play my itunes music, a Nikon D80 I take photos with but I don’t take the photos off the camera until three months later.

I don’t need these things but Its hard to part with them. I know I can justify keeping them because myself as an irrational human being wants to keep them, but I want you to listen to your robot mind.

I’m getting rid of my red stapler today and I want you to question what you picked up, and if you can come up with one reason to justify on how its distracting you from your end goal then throw it out now.

Your end goal awaits you.

The problem is when your working with multiple people on a git repos you can’t work in master otherwise when you pull changes, you’ll have a messy merge and when you push you’ll make a bunch of messy lines in your git tree, and you’ll get yelled at for making those messy lines.

I want to go through the steps with you to get your git tree to look like one straight line. Look at the model below to understand what you need to do.

Lets go through the step of adding a new feature:

Make sure we’re on master

git checkout master

Make sure our master is up-to-date

git pull

Create a new branch called new_feature

git checkout -b new_feature

Make changes and commit as much as you want

git commit

1. Now we’re ready to push our changes so lets make sure our
master is up-to-date

git checkout master
git pull

2. Lets rebase (If everything was up-to-date skip this step)

git checkout new_feature
git rebase master

3. Merge new_feature into your master

git checkout master
git merge new_feature

4. Push changes

git push

That’s all there is to it! Single clean line, nobody is yelling at you, and you can make fun of your coding friends who have never rebased before.