Question

For example, let’s say we have Users, which are related to Groups, Events, and other Users by Memberships, Rsvps, and Friendships, respectively.

Where should we refer to instances of objects by their functional/relational names (“member”, “rsvp”, “friend”) and where should we refer to instances of objects by their class names (“users”)? i.e. When is a User a “user”, and when is a User a “member”?

Which do we use in the Model? (group.rb for this example)

has_many :members, through: :memberships, source: :user
# vs.
has_many :users, through: :memberships

Which do we use in the Controller? (groups_controller.rb in this example)

@members = @group.members                    # or @group.users, depending on the model
# vs.
@users = @group.users

Which do we use in the View? (groups/show.html.haml in this example)

- @members.each do |member|                  # or @users.each, depending on the controller
  = "This is a member named #{member.name}"
-# vs.
- @users.each do |user|
  = "This is a member named #{user.name}"

It seems more readable to use the functional/relational name, but easier to remember with the class name. Has anyone found (or invented!) a thorough and logical convention for this sort of thing?

Edit:

1. changed “easier to remember and refactor” to “easier to remember”

Answer 1

My convention is to use always the function/relation name. I don’t understand why do you say it’s easier to remember and refactor with the class name. I personally find that everything is easier when you use the function/relation name. It’s also more “flexible” because if tomorrow you decide to allow groups to be inside other groups, then member still has sense, yet users isn’t quite that right… Users or the class name is the “current” implementation/solution of what you are using… The functional or relation name is how that object will be used… It’s more related to the “interface” or what you expect it to have… So you are focusing on what thing it should do, and what it should solve, and not in how it does it ATM.

It’s also generally easy to deduce the type or possible types of something by looking at the context, and or/running tests, so I think that the functional relational name adds a lot of useful information, while the other adds useless information, that might be more adversary than good.