Prompt:

Part I Discuss the steps of class design and the importance of each step to the overall design.

Part II Discuss the application of the GRASP principles in Class Design discussed in Larman (2001) and how they supplement the steps of class design.

post 1: Part I

The steps of class design are bridging the gap, realizing use cases, designing algorithms, recursing downward, refactoring, optimizing the design, reifying behavior, adjusting inheritance, and organizing class design, and adding operations to classes in design.

Bridging the Gap

To bridge the gap, we must create intermediate elements, which are going to be helpful for the next level. These elements may be operations, classes or other UML constructs.

Realizing Use Cases

Use cases define the system level behavior, so while designing we must create new operations and new objects that can provide this behavior and list the responsibilities of use case or operations.

Designing Algorithm

Algorithms show us how the operation does what it does. Steps for this step is choosing an algorithm, choosing its data structure, defining internal classes and operations, and assigning the operations to the appropriate classes.

Recursing Downward

Downward recursion happens in two main ways, namely by functionality and by mechanism. The required high-level functionality is broken into lesser operations and similar operations are combined and attached to classes. We must attach an operation to a class and reuse it. When providing functionality we need a variety of mechanisms to store information, to sequence control. Coordinate objects, transmit information, and perform computations, etc..

Refactoring

A large design is rarely perfect on the first try. Typically, the initial design of a set of operations will have inconsistencies, inefficiencies, and redundancies. We must revisit the design and rework classes and operations, to prevent the application from becoming weak, difficult to comprehend, and awkward to extend. We refactor to improve design without altering the external function. It helps make the design clean, modular, and understandable.

Optimizing the Design

Design optimization involves adding redundant associations for efficient access paths, rearranging the computation for better efficiency, and saving the intermediate result to avoid recomputation.

Reification of Behavior

Reification is the promotion of something that isn’t an object into an object. It adds complexity but also expands the flexibility of a system.

Adjustment of Inheritance

We adjust the definition of classes and operation to increase the inheritance through a few steps. These steps are rearranging classes and operations to increase inheritance, abstracting common behaviors out of groups of classes, and using delegation to share behavior when inheritance is semantically invalid.

Organizing a Class Design

When organizing a class design, we make the design better by hiding internal information from outside view, maintaining coherence of entities, and fine-tuning definition packages.

Part II

The GRASP (General Responsibility Assignment Software Patterns) principles are a set of nine fundamental principles in object design and responsibility assignment. They are used to help in the design of object-oriented software. The different patterns and principles used in GRASP are controller, creator, indirection, information expert, low coupling, high cohesion, polymorphism, protected variations, and pure fabrication. The GRASP principles supplement the steps of class design by providing a set of guidelines for assigning responsibilities to classes. The GRASP principles help in deciding which responsibility should be assigned to which object/class. They identify the objects and responsibilities from the problem domain and also identify how objects interact with each other. They define a blueprint for those objects – i.e. class with methods implementing those responsibilities.

Have a nice week!

Post 2: Part I – There are nine steps that need to be followed in class design. These include:

Bridge the gap from high-level requirements to low-level services. 

– Bridging the gap is all about using your resources effectively. You have your available resources and your desired resources. The gap is what falls in the middle of the issues the user has at hand. Thinking of ways to be able to overcome the issues is the gap, thus getting the user to the desired features.

Realize use cases with operations. 

-Use cases define system-level behavior. During design, you must invent new operations and new objects that provide this behavior. Much like all the designs we have done over the past six weeks, the use cases are defined have behaviors and relationships. 

Formulate an algorithm for each operation.

-The analysis specification tells what the operation does for its clients, but the algorithm shows how it is done. Here we choosing, selecting, defining, and assigning operations, algorithms, and classes.

Recurse downward to design operations that support higher-level operations.

-Recursion stops when you have operations that are already available or that are straightforward to implement.

Refactor the model for a cleaner design. 

-Refactoring a model essentially means going back and redesigning models after more information has been added. This includes fleshing out operations for additional use cases. Cleaning up, making things more understandable, and continuing development.

Optimize access paths to data.

– Essentially turning roadblocks and issues into solutions.  This all entails critical thinking as the user is reworking paths rearranging for better efficiency, and avoiding re-computation.  

Reify behavior that must be manipulated.    

-The promotion of something that is not an object into an object. The behavior usually meets this description. If you reify behavior, you can store it, pass it to other operations, and transform it. Reification adds complexity but can dramatically expand the flexibility of a system.

Organize classes and associations.

– Keeping code clean! You can keep this tidy by following these simple steps! Hide internal information from outside view. Maintain coherence of entities and fine-tune the definition of packages.

Part II

GRASP is an acronym for General Responsibility Assignment Software Patterns. In our reading, there are nine patterns discussed. Information Expert, Creator, Controller, Low Coupling, High Cohesion, Polymorphism, Pure Fabrication, Indirection, and Protected Variations. GRASP is essentially a way to cheat the system and supplement steps used in class design because it helps the user answer more simple questions than being bombarded with higher difficult questions to answer.