Responsibility-driven design

Question

I am quite confused about the responsibility-driven design concept. Mainly because of ever so slightly changing definitions depending on the source.

Quoting BlueJ (the book I am learning that teaches Java):

Responsibility-driven design expresses the idea that each class should be responsible for handling its own data. Often, when we need to add some new functionality to an application, we need to ask ourselves in which class we should add a method to implement this new function. Which class should be responsible for the task? The answer is that the class that is responsible for storing some data should also be responsible for manipulating it.

Later, in a "concept box" in the BlueJ book:

Reponsibility-driven design is the process of designing classes by assigning well-defined responsibilites to each class. This process can be used to determine which class should implement which part of an application function.

This second definition confuses me, as I don't see how that correlates to the first "definition"; the one saying that "it expresses the idea that each class should be responsible for handling its own data".

Will someone please shed some light on the concept of responsibility-driven design?

Answer 1

The class responsibility means the purpose of a class expressed in terms of things that it should take care of.

The term emerged with the CRC cards (Class, Responsibility, Collaboration), an XP technique that was presented the first time in 1989 by Beck & Cunningham in a paper about teaching object oriented thinking (full version):

Responsibilities identify problems to be solved. The solutions will exist in many versions and refinements. A responsibility serves as a handle for discussing potential solutions. The responsibilities of an object are expressed by a handful of short verb phrases, each containing an active verb. The more that can be expressedby these phrases, the more powerful and concise the design. Again, searching for just the right words is a valuable use of time while designing.
- Kent Beck & Ward Cunningham (OOPSALA 1989)

The goal it to have clear boundaries in the collaborations, about what class does what. Your second definition is exactly about this, expressed in a compact and elegant way.

Your first definition is not incorrect but misleading. In fact, it's not a definition, it's the practical consequence of responsibility driven design, combined with elementary OO practices:

• each class should have the data it needs and be in charge of its own data;
• data should anyway be encapsulated, so that the class should manipulate the data belonging to its responsibility;
• if one class starts to get too much interested in data of other classes, it's feature envy, which is a symptom of fuzzy boundaries in the class responsibilities (and in addition probably missing encapsulation as well).

Caution: "responsibility" means different things to different persons. In the OO literature, you'll also find the "Single Responsibility Principle (SRP)". Be aware that the naming of this principle is confusing, since the responsibility meant in the SRP has nothing to do with the responsibility OF the class but deals with the responsibility FOR the class.