Rebecca Wirfs-Brock Quotes

10 Sourced Quotes

Frameworks are skeletal structures of programs that must be fleshed out to build a complete application. For example, a windowing system or a simulation system can both be viewed as frameworks fleshed out by a windowed application or a simulation, respectively.

Rebecca Wirfs-Brock
The goal of responsibility-driven design is to improve encapsulation. It does so by viewing a program in terms of the client/server model.

Rebecca Wirfs-Brock
Users can work with analysts and object designers to formulate and tune system requirements. People from business, analytical and object design disciplines can come together, learn from each other and generate meaningful descriptions of systems that are to be built. Each participant and each project has slightly different concerns and needs. Practical application of use cases can go a long way to improve our ability to deliver just what the customer ordered.

Rebecca Wirfs-Brock
Frameworks are white boxes to those that make use of them. Application developers must be able to quickly understand the structure of a framework, and how to write code that will fit into the framework. Frameworks are reusable designs as well as reusable code.

Rebecca Wirfs-Brock
A subsystem is a set of classes (and possibly other subsystems) collaborating to fulfill a set of responsibilities. Although subsystems do not exist as the software executes, they are useful conceptual entities.

Rebecca Wirfs-Brock
Responsibility-driven design specifies object behavior before object structure and other implementation considerations are determined. We have found that it minimizes the rework required for major design changes.

Rebecca Wirfs-Brock
Object-oriented programming increases the value of these metrics by managing this complexity. The most effective tool available for dealing with complexity is abstraction. Many types of abstraction can be used, but encapsulation is the main form of abstraction by which complexity is managed in object-oriented programming.
Programming in an object-oriented language, however, does not ensure that the complexity of an application will be well encapsulated. Applying good programming techniques can improve encapsulation, but the full benefit of object-oriented programming can be realized only if encapsulation is a recognized goal of the design process.

Rebecca Wirfs-Brock
Object-oriented programming languages support encapsulation, thereby improving the ability of software to be reused, refined, tested, maintained, and extended. The full benefit of this support can only be realized if encapsulation is maximized during the design process.
We argue that design practices which take a data-driven approach fail to maximize encapsulation because they focus too quickly on the implementation of objects. We propose an alternative object-oriented design method which takes a responsibility-driven approach. We show how such an approach can increase the encapsulation by deferring implementation issues until a later stage.

Rebecca Wirfs-Brock
Experienced object designers explore the design space from many different angles. They refine ideas of how their system should respond while they are in the middle of building and discarding ideas about how their design should work. Getting a design to gel involves making assumptions, seeing how they play out, changing one's mind or perspective slightly and re-iterating. Design is a difficult, involved task. It inherently is a non-linear process. Yet, we are asked to trace our design results back to system requirements. And, if we uncover some implications during design, we'd like to tune our system requirements to reflect necessary design compromises.

Rebecca Wirfs-Brock
Responsibility-driven design is inspired by the client/server model. It focuses on the contract by asking: What actions is this object responsible for? and What information does this object share?

Rebecca Wirfs-Brock