Introduction

This part of the course focus on the following user stories:

As a software designer I want to create a design that adheres to basic design principles so that I am sure that it will "hold" when I add more functionality and start maintaining the system.
As a software designer I want to understand how to best design the interaction between objects so that I can create a robust and maintainable system.

The following concepts are introduced:

Abstraction
Coupling and Cohesion
Encapsulation
Code Refactoring
Design Principles
Design Patterns
Responsibility Driven Design
GRASP Patterns
- Information Expert
- Creator
- Controller
- Low Coupling
- High Cohesion
- Polymorphism
- Pure Fabrication
- Indirection
- Protected Variations

You are done when

You have studied the Fundamental Design Principles and understood them
You have studied the GRASP patterns and understood them

Please note that while this text is short, the concepts discussed in it are central to object oriented design. Understanding the basic object oriented principles (for example as expressed in the GRASP patterns) is essential to create a good and sustainable software design. Please do spend some extra time on the concepts in this sprint to make sure you fully understand how to use them in your design work. This is what will transform you from a good software designer to a great one!

Fundamental Design Principles

Object Oriented design principles are so deeply ingrained in how we do OO design that we rarely even think about them once we know them -- we just do. You will not list that "you have created class X according to design principle Y" anywhere, since it is expected that you have used all principles all the time (or have had a very good reason not to use them).

Some design principles have fancy names (you'll find them under Further Reading), and they are often described one by one as if you can first apply one, then the next, and so on. In reality you work with all of them at once, and they are essentially different aspects of a few fundamental principles:

Principle	Description
Abstraction	Focus on relevant properties
Coupling and Cohesion	Independent entities, but where the internals are strongly related
Decomposition and Modularisation	Small entities with well defined and non-overlapping functionalities or responsibilities
Encapsulation	Hide the internals so they are inaccessible from outside the entity
Separation of Interface and Implementation	Separate the public interface from implementation details
Sufficiency, Completeness, and Primitiveness	Keep entities as small as possible, but not smaller. Entities should capture all important characteristica of an abstraction but nothing more.

To put this into the context of a single class, this means that a good class has:

A single, well-defined abstraction and well-defined responsibilities
- Tip: Let classes distribute work to other classes
- Tip: avoid "God Classes" that tries to do everything
Has low coupling to other classes
- Tip: Minimise fan-out in a class
Has a sufficient and complete public interface to be able to access the behaviour and state relevant for the abstraction that the class models
Has a primitive public interface that does not expose anything more than necessary to the outside.
- Tip: All data should be hidden within the class.
- Tip: Do not clutter the public interface with items that users of that class are not interested in or able to use.
Has high cohesion (the methods and attributes belong strongly together)
- Tip: Most of the methods defined on a class should be using most of the data in the class most of the time.

Responsibility Driven Design

These are just some of the principles for how to define classes, and together they amount to that there are basic principles for how you should assign responsibility of doing or knowing things to different classes.

Many of these fundamental object oriented design principles have also been expressed in a slightly more accessible way in the course book. Larman calls them GRASP patterns, and the idea is that when you are doing your design you always try to define the responsibilities of the involved objects and classes according to these GRASP patterns. This is why he also refers to them as Responsibility Driven Design. The patterns are listed on the inside of the book cover:

Information Expert
Creator
Controller
Low Coupling
High Cohesion
Polymorphism
Pure Fabrication
Indirection
Protected Variations

There is little point in me going through these in text. We have plenty of time to talk about this during the lectures, though. But they are important. Make sure you understand the principles of each one of the GRASP patterns. Think about how you may apply them in different settings. Discuss them with your classmates, and use the course discussion forum. How might they impact your design?