poodr | Practical Object-Oriented Design in Ruby | Web Framework library

If I send you a letter saying "please, compute 2+2 for me", and I get a letter back which says "4", I have no idea how you come up with that answer, you may have memorized it, you may have looked it up, you may have computed it by hand, you may have used a calculator, you may have sent a letter to someone else asking them to compute 2+2, you may have sent several letters to several other people asking them to compute sub-problems of 2+2, you may have read the letter and decided based on its contents to pass it on to a specialist, you may have not read the letter and just blindly passed it on to someone else without even opening it, or your secretary may have opened it and answered on your behalf without you even knowing about it.

That's the fundamental nature of messaging: I cannot, should not, and must not know how you were able to answer. The only thing I can observe is the answer. As long as the answer is correct, it doesn't matter to me how the answer was obtained. Maybe it was printed out, mailed to China, computed by hand in an office, then mailed back and scanned. I don't know and I don't care.

• Is this line of thinking correct?

Yes.

• Is this what it means by intent and implementation separation?

I am not familiar with that phrase. Is that something from the book? If yes, you should explain what it means in your question.

• Or the analogy doesn't fall it line at all.

No, the messaging metaphor is a good one. It is the fundamental idea of OO. Classes are irrelevant, even objects are irrelevant. Messaging is what it's all about.

It's actually totally OK to use instance variables within instance methods. In fact, that's what they're for! Setters and getters allow things outside the instance to access variables inside the instance. They (basically) define instance methods for the class like this:

1) Obviously not, it performs JOIN of books & authors tables. What you've made requires 2 queries, instead of 1 join you'll have book.find(id) and author.find(book.author_id).

2) JOIN should be faster.

3) Since last_name is a public interface, it absolutely doesn't violate design principles. It would violate principles if you were accessing author's last name from outside like that: Book.find(1).author.last_name - that's a bad thing. Correct is: Book.find(1).authors_last_name - and accessing author's name inside Model class.

Your provided example seems to be overcomplicated to me.

According to the example you shared, you only want to get full name of the book's author. So, the idea of splitting responsibility is correct, but in Author class should be simple instance method full_name, like:

Ruby seems to place unusual emphasis on the intent of names and the implications of them. For example, unwrap_spiral implies that it might do the operation in-place unless there was a compantion method like unwrap_spiral! that made it clear it didn't.

unwrapped_spiral may be a shade too verbose. It's not clear why spiral factors into this so much when unwrapped might suffice.

Another thing to consider is organizing methods that operate on spiral under the same alphabetic ordering: spiral_unwrap or spiral_unwrapped.

I assume, this has been created with a painting tool, not an UML CASE tool.

1. (up to 3.) This naming is wrong. The lifeline is either described with just the instance name, :classifier or as name:classifier. See p. 570 17.3.4.1 Lifeline in the spec:

A Lifeline is shown using a symbol that consists of a rectangle forming its “head” followed by a vertical line (which may be dashed) that represents the lifetime of the participant. Information identifying the lifeline is displayed inside the rectangle in the following format: