PlanetRubyOnRails - has_many :blogs, :through => :feeds

about that t-shirt…

Posted about 1 hour back at omg blog!! lol!!

So I had to simplify the Ruby Hoedown shirt design some (who knew adding a color was $500?). So, here it is in all its non-color correct preview glory:

They’re printed on a slightly worn looking red colored shirt (”cardinal,” if you will). They should look really good I think. Thanks to the folks at CustomInk for being awesome again this year.

Look forward to my post about conference vendors; I think I have an excellent list of places to get good stuff.

Github Gist: Versioning For Pasted Code

Posted about 5 hours back at InfoQ Personalized Feed for unregistered user - Register to upgrade!

Demoed at RubyFringe, Github introduced a new service called Gist. While similar to popular paste services, it adds a twist: pasted snippets can be accessed like git repositories, which can be updated from the web interface. By Werner Schuster

Object Relational Mapping - User Case Studies

Posted about 9 hours back at InfoQ Personalized Feed for unregistered user - Register to upgrade!

Roberto Zicari, from ODBMS.org, collected interviews and stories from several users of Object/Relational mapping technologies. The main point of the cases was around "impedance mismatch" between the object technology in the domain model and the relational technology in the data model. By Steven Robbins

wiki.rubyonrails.org now running on Phusion Passenger

Posted about 12 hours back at Phusion Corporate Blog

Just in case you haven’t noticed yet, http://wiki.rubyonrails.org/ is now running Phusion Passenger and Ruby Enterprise Edition. We migrated them a few days ago, and other than a MySQL failure yesterday, it had been rock solid ever since. People have complained about wiki.rubyonrails.org being down often, but the uptime should be a lot better now.

Java in Ruby

Posted about 15 hours back at ones zeros majors and minors

Witness as Ruby dons the fake mustache and bifocals of burly Java:

_{-- Delivered by Feed43 service}

Ruby: Underuse of Modules

Posted about 15 hours back at Jay Fields Thoughts

When I began seriously using Ruby I noticed two things that I didn't like about the language.

There's no method to get the metaclass.
Some people create modules as a hint that they reopened the class.

It's a few years later and I've noticed a few interesting things.

I can't remember the last time I actually wanted a method to get the metaclass.
If you use a module to add behavior your behavior becomes part of the ancestor tree, which is significantly more helpful than putting your behavior directly on the class.

No metaclass method necessary
In April 2005, Why gave us Seeing Metaclasses Clearly. I'm not sure the article actually helped me see metaclasses clearly, but I know I pasted that first block of code into several of my first Ruby projects. I used metaclasses in every way possible, several of which were probably inappropriate, and saw exactly what was possible, desirable, and painful.

I thought I had a good understanding of the proper uses for metaclasses, and then Ali Aghareza brought me a fresh point of view: defining methods on a metaclass is just mean.

We were on the phone talking about who knows what, and he brought up a blog entry I'd written where I dynamically defined delegation methods on the metaclass based on a constructor argument. He pointed out that doing so limited your ability to change the method behavior in the future. I created some simple examples and found out he was right, which lead to my blog entry on why you should Extend modules instead of defining methods on a metaclass.

Ever since that conversation and the subsequent blog entry, I've been using modules instead of accessing the metaclass directly. "Just in case someone wants to redefine behavior" isn't really a good enough reason for me if the level of effort increases, but in this case I found the code to be easier to follow when I used modules. In programming, there are few win-win situations, but Ali definitely showed me one on this occasion.

If you interact with a metaclass directly, do a quick spike where you introduce a module instead. I think you'll be happy with the resulting code.

Include modules instead of reopening classes
In January of 2007 I wrote a blog entry titled Class Reopening Hints. I didn't write it because I thought it was very valuable, I wrote it so developers afraid of open classes could get some sleep at night. Those guys think we are going to bring the end of the world with our crazy open classes, and I wanted to let them know we'd at least thought about the situation.

I'm really not kidding, I thought the entry was a puff piece, but it made some people feel better about Ruby so I put it together. I never followed the Use modules instead of adding behavior directly advice though, and I don't think many other Rubyists did either. It was extra effort, and I didn't see the benefit. In over two and an half years working with Ruby I've never once had a problem finding where behavior was defined. With that kind of experience, I couldn't justify the extra effort of defining a module -- until the day I wanted to change the behavior of Object#expects (defined by Mocha). I was able to work around the fact that Mocha defines the expects method directly on Object, but the solution was anything but pretty.

It turns out, using modules instead of adding behavior directly to a reopened class has one large benefit: I can easily define new behavior on a class by including a new module. If you only need new behavior, then defining a new method on the class would be fine. But, if you want to preserve the original behavior, having it as an ancestor is much better.

Take the following example. This example assumes that a method hello has been defined on object. Your task is to change the hello method to include the original behavior and add a name.

# original hello definition
class Object
  def hello
    "hello"
  end
end

# your version with additional behavior
class Object
  alias old_hello hello
  def hello(name)
    "#{old_hello} #{name}"
  end
end

hello("Ali") # => "hello Ali"

That code isn't terrible. In fact, there are a few different ways to redefine methods and access the original behavior, but none of them look as nice as the following example.

# original hello definition
class Object
  module Hello
    def hello
      "hello"
    end
  end
  include Hello
end

# your version with additional behavior
class Object
  module HelloName
    def hello(name)
      "#{super()} #{name}"
    end
  end
  include HelloName
end

hello("Ali") # => "hello Ali"

When you have an ancestor, the behavior is only a super call away.

note:Yes, I've also reopened the class to include the module, but when I talk about reopening the class I'm talking about defining the behavior directly on the reopened class. I could have also included the module by using Object.send :include, HelloName. Do whichever you like, it's not pertinent to this discussion.

Prefer Modules to metaclasses and reopened classes
The previous example illustrates why you should prefer modules, it gives simple access to your method behavior to anyone who wishes to alter but reuse the original behavior. This fact applies to both classes that include modules and instances that extend modules.

So why didn't Matz give us first class access to the metaclass? Who cares. He probably knew extending modules was a better solution, but even if he didn't -- it is. He didn't give you a method to access the metaclass, and whether he knew it or not, you don't need it.

A Great Set of IronRuby Tutorials To Bring C# Developers Into The Ruby Fold

Posted about 16 hours back at Ruby Inside

IronRuby is a .NET implementation of Ruby being developed by Microsoft (specifically, by John Lam). The project has matured significantly in the past year, and IronRuby is well on its way to running Rails applications (it already works with very simple ones). IronRuby's major benefit is that it allows Ruby code to access a massive range of .NET libraries and services.

Justin Etheredge has put together a great set of tutorial blog posts designed to get you up to speed with IronRuby:

Getting IronRuby Up and Running walks you through getting the source code, compiling it with Visual Studio 2008 (if you don't have this, a link to the free "Express" edition is provided), associating the .rb file extension, and running some initial tests.

Running Applications in IronRuby walks you through writing a very small example script and running it with IronRuby.

Learning Ruby via IronRuby and C# Part 1 is a Ruby tutorial aimed at C# developers, with some comparisons between the two languages.

Learning Ruby via IronRuby and C# Part 2 continues onward.

Justin seems to have a real knack for putting these tutorials together, and they seem to be popular with C# developers, so if you want to point any C# or .NET stalwarts you know to Ruby, these posts are a great starting point.

Thoughts On Software Architecture and Corporate Structure

Posted about 21 hours back at InfoQ Personalized Feed for unregistered user - Register to upgrade!

Many important challenges faced by a software architect for a large company have as much to do with the organization as technology. In a recent blog entry, Dan Greenblog drew parallels between the principals behind software architecture and effective organizational structures. By Mark Figley

Twitter Images

Posted about 21 hours back at ones zeros majors and minors

I wanted an easy way to share tweets in Campfire. @shayarnett delivered.

_{-- Delivered by Feed43 service}

Interview: Avi Bryant on DabbleDB, Smalltalk and Persistence

Posted about 24 hours back at InfoQ Personalized Feed for unregistered user - Register to upgrade!

In this interview from QCon 2008, Avi Bryant talks about his Smalltalk web framework Seaside and DabbleDB. Also: Avi explains how DabbleDB uses Smalltalk images for persistence instead of an RDBMs and how to make Squeak scale. By Werner Schuster

JRuby Roundup: 1.1.3, rcov4jr, Rubinius MVM and FFI

Posted 1 day back at InfoQ Personalized Feed for unregistered user - Register to upgrade!

JRuby 1.1.3 was released with Gems 1.2, improved performance, and many other fixes. Meanwhile the library support for JRuby increases, with work on a JRuby version of rcov in the works, as well as a ports of Rubinius' Foreign Function Interface and its MVM API. By Werner Schuster

rails coding with vim and autotest

Posted 1 day back at Mike Mondragon

Here is a screen shot of my current environment for programming Rails.

Layout

I’m on Linux and using Gnome as my desktop. On the left hand side is a gnome terminal with autotest running and on the right hand side is gvim. Notice that gvim is split into two horizontal windows the upper is dedicated to the functional code and the lower is dedicated to spec/test code. btw, I’m also using tpope’s rails.vim plugin in gvim as well.

I learned this particular style of having autotest and gvim with functional and testing code all viewable in one location from Eric Hodel Its great, everything is in one place, autotest gives immediate feedback when I’ve broken my code and my functional code and testing code are viewable together.

script it

I wrote a script called railsvim that when called with a rails project directory will open the gnome terminal and gvim in this configuration centered on my desktop. That way I don’t have to place and size all the windows by hand saving me time, e.g.

railsvim ~/projects/superfu

The script is hosted on gist if you like to copy it: railsvim . Looking at a copy of the script below you will find that that gnome terminal is opened with three tabs, one for script/server, one for script/console, and one for autotest which has focus by default since its last tab created.

#!/bin/bash
DIR="${1}" 

if [ ! -d "${DIR}" ]; then
echo "call me with a directory, e.g.:" 
  echo "${0} /some/path/to/dir" 
  exit 1
fi

gnome-terminal --geometry=130x35+345+250 \
               --window --working-directory=${DIR} -t "script server" -e "ruby script/server" \
               --tab --working-directory=${DIR} -t "script console" -e "ruby script/console" \
               --tab --working-directory=${DIR} -t "autotest" -x autotest &

gvim -c ":wincmd s" -geometry 120x60+1285+0 ${DIR} &

You’ll have to play with the geometry settings for the gnome terminal and gvim to customize the placements for your desktop.

resources

My railsvim script:

monde’s railsvim @ gist.github.com

Hacking/automating the Linux desktop with wmctrl and others:

tpope (“TextMate may be the latest craze for developing Ruby on Rails applications, but Vim is forever”) rails.vim plugin for powerful vim and rails coding integration

If you have textmate envy here’s how to turn your gvim into a ghetto with their kind of font:

Vim Users, cure your Textmate envy 1

Zed Shaw Ringtone -- Matz can't patch

Posted 1 day back at Smarticus - Home

Rubyfringe was a great time. The diversity of presentation content was unique and very entertaining. Everyone’s favorite person to hate, Zed Shaw put on a live show where he recorded a few interesting songs.

One of the songs, “Matz can’t Patch”, was particularly funny to me, so I created a ring tone, so I could have it with me at all times on my iPhone.

A few people have requested that I share, so I present to you the Matz can’t Patch ringtone. I believe you can just import it to iTunes, and it will just work. If not, I’ll post it in another format that will be more accessible.

MVC Public Service Announcement #5 : Outdated HTML

Posted 1 day back at Rails Envy - Home

We were just holding out on you. There's one more after this one but it's not done yet.

MVC Public Service Announcement #5 : Outdated HTML

Posted 1 day back at Rails Envy - Home

We were just holding out on you. There's one more after this one but it's not done yet.

1 2 3 ... 474