How do you divide a program into methods?

Divide your program into methods that perform one identifiable task. Keep all of the operations in a method at the same level of abstraction. This will naturally result in programs with many small methods, each a few lines long

• Well chosen message names let you correctly assume the meaning of invoked code
• The opportunity to communicate through intention revealing message names is the most compelling reason to keep methods small
  • People can read your programs much more quickly and accurately if they can understand them in detail, then chunk those details into higher level structures
  • Deviding a program into methods gives you an opportunity to guide that chunking
• Small methods ease maintenance
• Small methods make inheritance work smoothly
• How?
  • Top-down
    • invoke several smaller methods, (without having an implementation yet)
    • A thought tool for breaking your development into pieces
  • Bottom-up
    • Extract Method

How do you represent instance creation?

Provide methods that create well-formed instances. Pass all required parameters to them

• How?
  1. Keep parameters for a Constructor Method simple
  2. Make sure there is a method to represent each valid way to create an instance
     • Most classes only have a single way to create an instance
     • For the rare exceptions, use Constructor Methods for the common cases and provide Accessor Methods for the remainder
• Describe parameters' roles, instead of types

How do you set instance variables from the parameters to a Constructor Method?

Code a single private method that sets all the variables Preface its name with set, then the names of the variables

• Separate two circumstances
  1. State initialization during instance creation
  2. State change during computation
• Explicit Initialization

What is the external interface for creating a new object when a Constructor Method is too wordy?

Represent object creation as a message to one of the arguments to the Constructor Method. Add no more than three of these Shortcut Constructor Methods per system you develop.

• Two Problems with an explicit class-based interface for object-creation
  1. wordy
  2. can be misleading (?)
• The problems with representing object creation as a message to one of the arguments
  1. It puts a burden on the programmer to remember the message
  2. It cannot be easily looked up by looking at the instance creation methods of the class

How do you convert information from one object's format to another's?

Convert from one object to another rather than overwhelm any one object's protocol

• Converter Method
• Converter Constructor Method

How do you represent simple conversion of an object to another object with the same protocol but different format?

1. Provide a method in the object to be converted that converts to the new object
2. Name the method by prepending as to the class of the object returned

• Problems with representing conversion as methods in the object to be converted
  1. There is no limit to the number of methods that can be added
  2. It ties the receiver with a class of which it would otherwise be obvious
• Only representing conversions with a message to the object to be converted when
  1. The source and destination of conversion share the same protocol
  2. There is only one reasonable way to implement the conversion

How do you represent the conversion of an object to another with different protocol

Make a Constructor Method that takes the object to be converted as an argument

Date.from_string

How do you represent testing a property of an object?

1. Provide a method that returns a Boolean.
2. Name it by prefacing the name with a form of "be" (is, was, will, etc.) (Or postfix the name with ?)

• Two decisions here:
  1. Deciding what to return from a method that tests a property
     • It's far easier to maintain a relationship based solely on messages. (Boolean)
  2. What you should name the method
     • Switch#on?
• Provide an inverse method if you use it a lot

How do you order objects with respect to each other?

Implement <= to return true if the receiver should be ordered before the argument

• Ordering is often done in terms of Simple Delegation to the ordering of other objects
• Use a Temporarily Sorted Collection for multiple orderings

How do you code a smooth flow of messages?

1. Code a method on the parameter.
2. Derive its name from the original message
3. Take the original receiver as a parameter to the new method
4. Implement the method by sending the original message to the original receiver

• Good code has a rhythm that makes it easy to understand
• Make sure that all messages go through a single object, in a Composed Method

class Point
  def print_on(stream)
    x.print_on(stream)
    stream.next_put_all('@')
    y.print_on(stream)
  end
end

class Stream
  def print(object)
    object.print_on(self)
  end
end

class Point
  def print_on(stream)
    stream.print(x)
    stream.next_put_all('@')
    stream.print(y)
  end
end

How do you code a method where many lines of code share many arguments and temporary variables

1. Create a class named after the method.
2. Give it an instance variable for the receiver of the original method, each argument, and each temporary variable.
3. Give it a Constructor Method that takes the original receiver and the method arguments.
4. Give it one instance method, #compute, implemented by copying the body of the original method.
5. Replace the method with one that creates an instance of the new class and sends it #compute.

How do you represent pairs of actions that have to be taken together?

1. Code a method that takes a Block as an argument.
2. Name the method by appending “During: aBlock” to the name of the first method that needs to be invoked.
3. In the body of the Execute Around Method, invoke the first method, evaluate the block, then invoke the second method.

How do you code the default printing method

Override printOn: (#to_s) to provide information about an object's structure to the programmer

• Separate string interfaces for clients and debugging

How do you comment methods?

Communicate important information that is not obvious from the code in a comment at the beginning of the method

1. Method dependencies
2. TODO
3. Reasons for change, particularly base class (Git Message)

• Intention Revealing Selector communicates what the method does
• Type Suggesting Parameter Name says what the arguments are expected to be
• patterns like Query Method suggest return types
• Each method only computes a single case

How do you invoke computation?

Send a named message and let the receiving object decide what to do with it

• All procedural control structures, conditionals and loops, are implemented in terms of messages in Smalltalk

How do you execute one of several alternatives?

Send a message to one of several different kinds of objects, each of which executes one alternative

• Messages provide a disciplined way to handle theme-and-variation programming
  1. The variations live in different objects, they have much less opportunity to interfere with each other than just putting the variations in different parts of the same routine
  2. The object invoking the variations is also isolated from what variation is currently active

How do you invoke parts of a computation?

Send several messages to self

• Keep methods fit into a few lines, (less than 10, often 3 or 4)

How do you communicate your intent when the implementation is simple?

1. Send a message to self
2. Name the message so it communicates what is to be done rather than how it is to be done
3. Code a simple method for the message

• Intention Revealing Messages are the most extreme case of writing for readers instead of the computer

What od you name a method?

Name methods after what they accomplish

• Leave "how" to the various method bodies
• A simple exercise that will help you generalize names of messages with a single implementation
  1. Imagine a second, very different implementation
  2. Ask yourself if you'd give that method the same name
  3. If so, you've probably abstracted the name as much as you know how to at the moment

How can two objects cooperate when one wishes to conceal its representation?

1. Have the client send a message to the encoded object.
2. Pass a parameter to which the encoded object will send decoded messages

• How you distribute responsibility among objects (messages) is the critical decision, encoding (data structure) is a distant second

• example (#each)

  array.each do |item|
    item.decode
  end
  

How can you code a computation that has many cases, the cross product of two families of classes?

1. Send a message to the argument.
2. Append the class name of the receiver to the selector
3. Pass the receiver as an argument

• Visitor pattern and double dispatch in ruby - BigBinary Blog
• Example

  1. binary operator like +

     class Integer
       def +(number)
         number.add_integer(self)
       end
     
       def add_integer(integer)
         self.+(integer)
       end
     
       def add_float(float)
         self.to_float.add_float(float)
       end
     end
     
     class Float
       def +(number)
         number.add_float(self)
       end
     
       def add_integer(integer)
         self.add_float(integer.to_float)
       end
     
       def add_float(float)
         self.+(float)
       end
     end
     

  2. drag-and-drop operations

     You want to execute different code depending on what kind of object is
     being dragged over what kind of receiver
     

• In the worst cast, Double Dispatch can lead to N * M methods

  N

  the number of classes of the original receiver

  M

  the number of classes of the original argument

How do you code the interaction between two objects that need to remain independent?

Refine the protocol between the objects so the words used are consistent.

• Put all the methods to support a Mediating Protocol in a single method protocol, so that they are easy to find and duplicate

How can you invoke super-class behavior?

Invoke code in a super-class explicitly by sending a message to super instead of self

• like calling super in initialize
• Always check code using super carefully
  • *Change super to self if doing so does not change how the code executes

How do you add to a super-class' implementation of a method?

Override the method and send a message to super in the overriding method

How do you change part of the behavior of a super-class' method without modifying it?

Override the method and invoke super, then execute the code to modify the results

• Use Composed Method to split super method into smaller pieces and override some of them
• Use a Default Value Method to represent the default value

How does an object share implementation without inheritance?

Pass part of its work on to another object

• Use Simple Delegation when the delegate need know nothing about the original object
• Use Self Delegation when the identity of the original object or some of its state is needed by the delegate

How do you invoke a disinterested delegate?

Delegate messages unchanged

1. Is the identity of the delegating object important?
2. Is the state of the delegating object important to the delegate?

How do you implement delegation to an object that needs reference to the delegating object?

Pass along the delegating object (self) in an additional parameter

• Use Double Dispatch if the delegate needs different logic depending on who is delegating

How do you parameterize the behavior of an object?

Add a variable that will be used to trigger different behavior.

• Benefits and Drawbacks of Classes
  • Benefits
    • Useful to instantiate and/or specialize
  • Drawbacks
    • Puts a burden on writer to communicate its purpose and implementation well
    • A namespace across many classes is hard to manage
    • Classes are not flexible
      • You cannot change an existing object's class without completely ruining the ability to understand the code statically
• A large family of classes with only a single method each is unlikely to be valuable
• Consider before using Pluggable Behavior
  • How much flexibility do you need?
  • How many methods will need to vary dynamically?
  • How hard is it to follow the code?
  • Will clients need to specify the behavior to be plugged, or can it be hidden within the plugged object?

• Example

  User Interface components that have to display the contents of many
  different objets
  

How do you code simple instance specific behavior?

1. Add a variable that contains a selector to be performed.
2. Append "Message" to the Role Suggesting Instance Variable Name.
3. Create a Composed Method that simply performs the selector.

How do you code complex Pluggable behavior that is not quite worth its own class?

1. Add an instance variable to store a block.
2. Append "Block" to the Role Suggesting Instance Variable Name.
3. Create a Composed Method to evaluate the Block to invoke the Pluggable Behavior.

• Enormous Cost

  1. You can never statically analyze the code to understand the flow of control.

     Only by single stepping through the invocation of the block will the reader understand what is going on

  2. Blocks are more difficult to persist

How do you return a collection that is the collaborative result of several methods?

Add a parameter that collects their results to all of the submethods.

• married_man_and_unmarried_women

  def married_man_and_unmarried_women
    result = []
  
    people.each do |person|
      result << person if person.married? && person.man?
    end
  
    people.each do |person|
      result << person if person.unmarried? && person.woman?
    end
  
    result
  end
  

• Composed Method

  def married_man_and_unmarried_women
    married_men + unmarried_women
  end
  
  def married_men
    result = []
  
    people.each do |person|
      result << person if person.married? && person.man?
    end
  
    result
  end
  
  def unmarried_women
    result = []
  
    people.each do |person|
      result << person if person.married? && person.man?
    end
  
    result
  end
  

• Pass result into married_men and unmarried_women

  def married_man_and_unmarried_women
    result = []
  
    add_married_men_to(result)
    add_unmarried_women_to(result)
  
    result
  end
  
  def add_married_men_to(collection)
    people.each do |person|
      collection << person if person.married? && person.man?
    end
  end
  
  def add_unmarried_women_to(collection)
    people.each do |person|
      collection << person if person.married? && person.man?
    end
  end
  

How do you represent state, different values for which will exists in all instance of a class?

Declare an instance variable in the class

• FP languages never caught on for commercial software
  • The problem is that programmers think and model in terms of state
  • State is a pretty darn good way to think about the world
• State is good, but only when properly managed
  • It's manageable if it is chopped into little pieces, some alike and some different
  • Related programs are chopped into little pieces, some alike and some different
• Instance variables have a very important communicative role to play
  • Here's what I'm modeling with this object
  • Declare instance variables in order of importance in the class definition

How do you represent state whose presence varies from instance to instance?

1. Put variables that only some instances will have in a Dictionary stored in an instance variable called "properties"
2. Implement propertyAt: aSymbol and propertyAt: aSymbol put: anObject to access properties

• Cons
  • You can't read the code and understand what is going on
  • The programming tools don't support this style of programming as well
• Make sure that with any variables, all or nearly all instances shared are implemented as instance variables, not as entries on the property list
• Variable State is often used as a temporary convenience and never revisited, even though its generality is not used

How do you initialize instance variables to their default value?

1. Implement a method initialize that sets all the values explicitly.
2. Override the class message new to invoke it on new instances

• Emphasizes readability over flexibility

How do you initialize an instance variable to its default value?

1. Write a Getting Method for the variable.
2. Initialize it if necessary with a Default Value Method

• Emphasizes flexibility over readability
  • Change the default value by overriding the Default Value Method
  • You have to look at several methods to see all the values
• Prefer Explicit Initialization
  • Lots of flexibility is never used
  • Do it the simple way first
  • Fix it if it's a problem

How do you represent the default value of a variable?

1. Create a method that returns the value.
2. Prepend default to the name of the variable as the name of the method

How do you code a constant?

Create a method that returns the constant

• Drawbacks of Pools (A class with lots of Constants)
  • They make it too easy to stop making useful responsibilities and instead just spread data around
• Limit the visibility of constants to a single class
  • If you can refactor your code so that only a single class cares about a constant, you can represent that constant as a method

How do you get and set an instance variable's value

Access and set the variable directly

• You need to access Common State as readably as possible
• Accessing state is a topic like initialization (Two good answers for different needs)

  More readable

  Use the variables directly in all the methods that need their values

  More flexible

  Send a message every time you need to use or change an instance variable's value

  • Getter and setter can easily double the number of methods in your class
  • Twice as many methods to buy you flexibility that you may never use

• Direct Variable Access can make it hard to subclass a class

How do you get and set an instance variable's value

Access and set its value only through a Getting Method and Setting Method

• You need to access Common State as flexibly as possible

How do you provide access to an instance variable?

1. Provide a method that returns the value of the variable
2. Give it the same name as the variable

• Make getting methods private at first

How do you change the value of an instance variable?

1. Provide a method that returns the value of the variable
2. Give it the same name as the variable
3. Have it take a single parameter, the value to be set

• Setting Methods should be even more private

How do you provide access to an instance variable that holds a collection?

1. Provide methods that are implemented with Delegation to the collection.
2. To name the methods, add the name of the collection to the collection messages
   • Find a better word from the domain rather than just adding the collection message it delegates to the name (e.g. prefer employs? over includesEmployee)

• A simple Getting Method for a collection opens up too much of the implementation to the outside world
  • If the variable choose another collection class, the client code may break
  • The client code can change this object's state without the object knowing it (Break counter cache, etc.)
• Use Indirect Variable Access for a collection
  • You can do whatever other processing you need to (in the accessor)
  • But you have to implement all of these methods (getter, setter, etc.)
    • It's worth it in the long run

How do you provide safe, general access to collection elements?

1. Implement a method that executes a Block for each element of the collection
2. Name the method by concatenating the name of the collection and Do: (_each)

How do you set a Boolean property?

1. Create two methods beginning with be_
2. One has property name, the other the negation
3. Add toggle if the client doesn't want to know about the current state

• 2 Problems with just using Setting Method
  1. it exposes the representation of the status of the switch to clients
  2. it's hard to answer simple questions like "who turns on the switch?" (decide who is the best caller)
• The benefits this method provides are like what Query Method provides

What do you name an instance variable?

1. Name instance variables for the role they play in the computation
2. Make the name plural if the variable will hold a Collection

• 2 important pieces of information to communicate about any variable:
  1. What is its purpose(role)?
     • It helps direct their attention appropriately
     • Skim over irrelevant code that uses variable whose role is unrelated to reader's current purpose
     • Narrow reader's reading to relevant code
  2. How is it used?
     • its "type" ("class")
     • Substitution of objects is the heart of disciplined maintenance and reuse (Duck Typing / LSP)

How do you save the value of an expression for later use within a method?

1. Create a variable whose scope and extent is a single method
2. Declare it just below the method selector
3. Assign it as soon as the expression is valid

• Each variable has several features

  Scope

  The textual area within which it can be used

  Extent

  How long its value lasts

  Type

  The signature of messages sent to it

• Long extent, wide scope, and large type all make variables difficult to manage
  • Limiting the scope, extent, and type of variables wherever possible produces programs that are easier to understand, modify, and reuse
• Explicit and early declaration can help readers to start understand your code

How do you gradually collect values to be used later in a method?

When you need to collect or merge objects over a complex enumeration, use a temporary variable to hold the collection or merged value

• The right set of enumeration protocol would make this question moot
  • Inject:into: (reduce) often eliminates the need for a temporary variable

How do you improve the performance of a method?

1. Set a temporary variable to the value of the expression as soon as it is valid
2. Use the variable instead of the expression in the remainder of the method

• All performance tuning boils down to two techniques
  1. Execute code less often
  2. Execute code that costs less

How do you simplify a complex expression within a method?

1. Take a sub-expression out of the complex expression
2. Assign its value to a temporary variable before the complex expression
3. Use the variable instead in the complex expression

How do you use an expression several places in a method when its value may change?

1. Execute the expression once and set a temporary variable
2. Use the variable instead of the expression in the remainder of the method

What do you call a temporary variable?

Name a temporary variable for the role it plays in the computation

• 2 important dimensions to communicate about a variable
  1. Type
  2. Role
• Temporary variables' types are easy to guess
• Temporary variables' roles are hard to guess unless you give them role suggesting names

How do you represent a one-to-many relationship?

Use a Collection (Enumerable in Ruby)

• Iteration is the responsibility of the object representing the relationship itself
• The downside of Collection is the learning curve (a new vocabulary to manipulate data)

How do you code Collections whose size can't be determined when they are created?

Use an OrderedCollection (Array in Ruby) as your default dynamically sized Collection

• Cost
  • More memory usages (consider this problem latter)

How do you compactly code an OrderedCollection or Array where you have the same element many times in a row?

Use a RunArray to compress long runs of the same element

• Start with an OrderedCollection=/=Array first

• Migrate to RunArray for improvements

  [[50, 'style 1'], [200, 'style 2'], [90, 'style 3']]
  

• Use RunArray when inspecting an Array and there is an same element printing over and over again

How do you code a Collection whose elements are unique?

Use a Set

How do you code equality for new objects?

1. Define a method ==
2. Protect == so only objects of compatible classes will be fully tested for equality