NOOT

OOT

The above algorithm seems straightforward and simple enough. It involves imposing an external control structure to traverse an IList and stop at some appropriate point.  As illustrated in a subsequent section, such an algorithm is usually implemented in terms of a loop whose exit condition involves checking an IList for emptiness!

1. which object should be  responsible for determining whether or not the host's first is the last element?
2. which object should be responsible for returning the last element?  

The host's rest knows whether or not itself is empty, and thus can determine whether or not the host's first is actually the last element.  Therefore the responsibility for determining whether or not the host is holding the last element should be delegated to the host's rest.

Though the host's rest knows whether or not the host holds the last element, it does not have access to that element.  The only object capable of accessing this element is the host itself.

So knowing when to return the last element does not necessarily means capable of the task of returning that last element.  In general, knowing when some action must take place does not mean capable of carrying out that action.  These are two distinct responsibilities that need to be worked out between the host and its rest.

The above OO thought process leads to the idea of decomposing the task of removing the last element into two subtasks.

1. Ask the host's rest for help in determining whether or not the host is holding the last element.  When asking for help, the host will need to pass its first as a parameter to the helper task so that once the last element is discovered, it can then be returned.
2. Help the preceding IList remove its last element.  When helping the preceding (non-empty) IList to return the last element, an empty IList (IEmptyList) simply returns the input parameter (which is the first element of the preceding list), while a non-empty IList (INEList) will recursively ask its rest for help to return its last element by passing its first as a parameter.  This ought to work because the last element of an non-empty list is the last element of the preceding list.

Note that the above algorithm involves no notion of list traversal at all.  It entails decomposing the original task into smaller subtasks ("divide-and-conquer") and is only expressed in terms of which objects should be doing what and what pieces of information must be passed to each object's method in order to carry out each of the subtasks.

OOP calls for thinking in terms of  problem abstraction, task decomposition, and delegation of responsibilities.  It is a paradigm shift that emphasizes design and promotes a different way of thinking about formulating and solving problems.

Non Object-Oriented Algorithm (NOOA)

Non Object-Oriented Coding (NOOC)

The boolean expresssion

  list instanceof IEmptyList

will return true if it is of type IEmptyList, false otherwise.
  

If the IList is not empty, traverse the IList until the empty IEmptyList is reached, at which point ask the preceding IList to return its first. 

/**
* Static method of some class.
*/
public static void removeLast(IList list) {
  if (list instanceof IEmptyList) {
    throw new IllegalArgumentException("Empty list has no data.");
  }
  IList next = ((INEList)list).getRest();  
  while (!(next instanceof IEmptyList)) {
    list = next;
    next = ((INEList)list).getRest();
  }
  return ((INEList)list).getFirst();
}

Though the high level description of the algorithm seems simple enough, its translation into code is not that simple.

It is not apparent that the code is a faithful (and correct) translation of the algorithm statement.  It is error-prone because it involves a lot of tedious book-keeping and flow control.  For example, it is very easy to forget to type-cast list to INEList as shown in the above.

Object-Oriented Algorithm (OOA)

Object-Oriented Coding (OOC)

public class LastElement implements IListAlgo {
  // Singleton Design Pattern
    public static final LastElement Singleton = new LastElement();

    private LastElement() {
  }

  public Object emptyCase(IEmptyList host, Object inp) {
    throw new IllegalArgumentException("Empty list has no data.");
  }

When the IList host is not empty, ask the host's rest for help in determining whether or not the host is holding the last element, passing the host's first as a parameter just in case this is true and the last element needs to be returned.

  public Object nonEmptyCase(INEList host, Object inp) {
    return host.getRest().execute(HelpGetLast.Singleton, host.getFirst());
  }
}

public class HelpGetLast implements IListAlgo {
  // Singleton Design Pattern
    public static final HelpGetLast Singleton = new HelpGetLast();

    private HelpGGetLast() {
  }

  /**
  * @param inp the first element of the preceding host list.
  */  
  public Object emptyCase(IEmptyList host, Object inp) {
    return inp;
  }

  /**
  * The last element of the (non-empty) host is the
  * last element of the preceding host list.
  */
  public Object nonEmptyCase(INEList host, Object inp) {
    return host.getRest().execute(this, host.getFirst());
  }
}

The implementation code for the OO algorithm directly maps to the abstract high-level description of the algorithm and can be easily proved to be correct.

It is "declarative" in nature.  It does not involve any conditional to specify when to perform certain task.  It simply states what needs to be done for each type of the host IList.  Polymorphism is put to use to direct all flow control, reducing code complexity.