Emergence

Four rules of simple design - A design is "simple" if it follows these rules:

1. Runs all the tests
2. Contains no duplication
3. Expresses the intent of the programmer
4. Minimizes the number of classes and methods

• Refactoring the code - each time we add some code we should go back and check if we've dirtied the existing code - if so we need to clean up/refactor.

• No duplication - it adds additional work and complexity if you need to change something. Also, lines that look very similar but differ slightly can count as duplication. Even small amounts of repeated code can be cleaned:

  void scaleToOneDimension(...){
      if (Math.abs(desiredDimension - imageDimension) < errorThreshold) 
          return;
      float scalingFactor = ...;
      ...
      RenderedOp newImage = ImageUtilities.getScaledImage(image, scalingFactor,
          scalingFactor);
      image.dispose();
      System.gc();
      image = newImage;
  }
  void rotate(int degrees) {
      RenderedOp newImage = ImageUtilities.getRotatedImage(image, degrees);
      image.dispose();
      System.gc();
      image = newImage();
  }
  

  Could be changed to

  void scaleToOneDimension(...) {
      if (Math.abs(desiredDimension - imageDimension) < errorThreshold) 
          return;
      float scalingFactor = ...;
      ...
      replaceImage(ImageUtilities.getScaledImage(image, scalingFactor, 
          scalingFactor));
  }
  void rotate(int degrees) {
      replaceImage(ImageUtilities.getRotatedImage(image, degrees));
  }
  void replaceImage(RenderedOp newImage) {
      image.dispose();
      System.gc();
      image = newImage();
  }
  

  Additionally, the fact that we need replaceImage shows we violate the single responsibility principle; so the replaceImage method might be extracted into its own class.

• The template method pattern also helps eliminate duplication. For different sections of code that are largely the same with minor differences, break the code up into multiple higher level functions, and have different function implementations in the places that differ slightly.

  ex:

  class VacationPolicy
  {
      public void accrueVacation() {
          calculateBaseVacationHours();
          alterForLegalMinimums();
          applyToPayroll();
      }
      void calculateBaseVacationHours() {...}
      abstract void alterForLegalMinimums(); // to be implemented
      void applyToPayroll() {...}
  }
  class USVacationPolicy extends VacationPolicy
  {
      @Override void alterForLegalMinimums() {
          ...
      }
  }
  class EUVacationPolicy extends VacationPolicy
  {
      @Override void alterForLegalMinimums() {
          ...
      }
  }
  

• Expressing the intent of the programmer - Try to be careful and clear with your code (should be obvious what a class/function does, good names, short methods/classes) - basically take PRIDE in your code and have good craftsmanship - it should be clear that you tried and care about the code.

• Minimal classes and methods - although the above suggests adding many, many classes/methods/etc. in the name of expressiveness, don't go overboard - our goal is to have as few methods and classes while at the same time keeping the overall system small.