Talk Like A Duck : You Can't Judge a Book... Some Mental Traps in Learning Ruby

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by labria

Wed, 17 Oct 2007 18:17:51 -0400

I do use the Person[] in the rails console, through .irbrc config, but I surely would not use it in the app itself. When someone looks through my code, he expects Name[] to be an constant array, defined somewhere else (I would!). I wouldn’t like to confuse people to save a bit of typing. Name.find() is 4 symbols longer, but much more readable.

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by Jeremy

Thu, 18 Oct 2007 15:56:29 -0400

The object that it’s too similar to array is sort of silly. You could just as easily have a Hash that has a numeric key…

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by Bob

Thu, 18 Oct 2007 17:26:11 -0400

“just because 99% of the time when you see something “indexed” by an integer, that thing doesn’t have to be an Array.”

And just because 99% of the time turning the ignition switch in your car starts it, doesn’t mean you can’t have it turn on the radio every once in awhile.

There is something to be said for clarity and consistency in an interface. Just because you can do it, doesn’t mean that you should.

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by Pat Maddox

Fri, 19 Oct 2007 04:39:44 -0400

Another brief example:

foo = lambda {|a| a.succ}

foo[“c”] => “d”

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by Piers Cawley

Fri, 19 Oct 2007 06:30:06 -0400

Personally make @Model#[]@ be something that would make @Model[params[:model_id]]@ return either the specified model or throw a RecordNotfound exception if no such model exists.

Most of the time that’s going to be the same as find, but in cases like @/songs/my-sharona@, not so much.

But then, I loathe URLs that expose primary keys.

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by Ryan Bates

Fri, 19 Oct 2007 11:19:07 -0400

I think you lose much of the convenience of the square brackets in a real app because you’re rarely accessing the id direcly. Instead it’s more like:

Person[params[:id]]

Nested square brackets, ick. I prefer the original way:

Person.find(params[:id])

Also, making it easier to search by id directly like this might encourage it more. So you’d see more code like this:

Person[project.person_id]

Instead of this:

project.person

Just a thought.

Comment on You Can't Judge a Book... Some Mental Traps in Learning Ruby by jmoiron

Sat, 20 Oct 2007 02:03:59 -0400

I think that there are things that are useful as a convenience (like $() from prototype) that, because of their ubiquity and their vastly improved readability, can bend the rules a bit.

I strongly believe that abuse of the indexed/associative accessors rarely fall into this category.

I think it’s important for an API in particular not to reveal half-done abstractions for normal use. As a shortcut for an interactive session; by all means. But if you are implementing an index accessor for use inside program text, then your object better mimic an array to the fullest extent possible; it better have a length, iteration, etc.

If it doesn’t, then making your object look like an array is misleading, and you introduce more complexity by re-using that syntax than was originally present: your own example proves it.

Person.find(1)

What’s a person?

Person[1]

Now what’s a person?

A reader of your program (or the writers using your API) will have to think “Oh, is @a[10]@ a list or an ActiveRecord object?” every time that indexed accessor is used, and it isn’t always obvious (because it isn’t really always important). If I am implementing methods like these, I usually stop and think: “Am I going to be able to treat this like the type it looks like without having to think about it’s implementation?” If the answer is no, I don’t do it.

Writing an interface to functionality that doesn’t require you to think about the implementation of that interface when you use it is real expressiveness. Anything else is just “sugar abuse”.