Smalltalk Best Practice Patterns - Javascript

My best efforts of converting the patterns in SmallTalk best practices by Kent Beck in Javascript.

I've been working from Ruby conversions and conversions of the SmallTalk language itself to Java then to Javascript from my own intuition so some of the representations might be off.

PR's are welcomed with suggestions on improvements, fixes and contributions (look for the TODOs).

Purchase your own copy of the book here.

Most patterns are designed to preserve a balance between short-term and long-term needs. The bottlenecks throughout development come from the limitations in human communication. When you program, you have to think about how someone will read your code, not just how a computer will interpret it.

Good predictors of whether a Software project is in good shape:

Once and only once (DRY)
Lots of little pieces
Replacing objects
Moving objects
Objects that can be easily moved to new contexts
Ship a couple of systems first
Then generalise little pieces easily
Rates of change
Same level of abstraction
Don't put two rates of change together
Avoid this problem by making lots of little pieces

The problems in the construction of objects are universal

Name Classes
Relate Classes via inheritance and delegation
Relate methods in the same class and different classes
Name variables

Patterns record these problems and how to approach solving them. They are literacy form of capturing and transmitting common practice. Each pattern records a recurring problem, how to construct a solution for the problem and why the solution is appropriate.

Patterns from the book

Behaviour

Patterns for methods and messages. The problems you can solve by creating a new method. You will also find method pat- terns scattered throughout the remainder of the patterns, if a particular kind of method (like accessors) is tied to another pattern. The quick reference guide gathers all the method patterns together for easy reference.

Methods

Composed Method
Constructor Method
Constructor Parameter Method
Shortcut Constructor Method
Conversion
Converter Method
Converter Constructor Method
Query Method
Comparing Method
Reversing Method
Method Object
Execute Around Method
Debug Printing Method
Method Comment

Messages

Message
Choosing Message
Decomposing Message
Intention Revealing Message
Intention Revealing Selector
Dispatched Interpretation
Super
Extending Super
Modifying Super
Delegation
Simple Delegation
Self Delegation
Pluggable Behaviour
Pluggable Selector
Pluggable Block
Collecting Parameter

State

Patterns for using instance and temporary variables. You will find a discussion of the pros and cons of using accessor methods and direct variable access.

Instance Variables

Common State
Variable State
Explicit Initialization
Lazy Initialization
Default Value Method
Constant Method
Direct Variable Access
Indirect Variable Access
Getting Method
Setting Method
Collection Accessor Method
Enumeration Method
Boolean Property Setting Method
Role Suggesting Instance Variable Name

Temporary Variables

Temporary Variable
Collecting Temporary Variable
Caching Temporary Variable
Explaining Temporary Variable
Reusing Temporary Variable
Role Suggesting Temporary Variable Name

Collections

The major collection classes and messages in the form of patterns. You will also find common tricks using collections.

Classes

A brief introduction to how to use classes, since most of the topics regarding class creation are outside the scope of this book.

Collection
OrderedCollection
RunArray
Set
Equality Method
Hashing Method
Dictionary
SortedCollection
Array
ByteArray
Interval

Formatting

Inline Message Pattern
Type Suggesting Parameter Name
Indented Control Flow
Rectangular Block
Guard Clause
Conditional Expression
Simple Enumeration Parameter
Cascade
Yourself
Interesting Return Patterns

Patterns

Behaviour

Composed Method

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.

Anytime you are sending two or more messages from one object to another in a single method, you may be able to create a Composed Method in the receiver that combines those messages.

class Controller {
  controlInitialise() {
    console.log('Controller initialising...');
  }

  controlLoop() {
    console.log('Controller looping: 1, 2, 3');
  }

  controlTerminate() {
    console.log('Controller terminated');
  }

  controlActivity() {
    this.controlInitialise();
    this.controlLoop();
    this.controlTerminate();
  }
}

const controller = new Controller();

controller.controlActivity();
// => Controller initialising...
// => Controller looping: 1, 2, 3
// => Controller terminated

Constructor Method

How do you represent instance creation?

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

// TODO

Constructor Parameter Method

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

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

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

Shortcut Constructor Method

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.

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
};

// TODO
class Number {
  // original book example used @
  at(y) {
    return new Point(this, y)
  }
};

Conversion

Converter Method

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

Provide a method in the object to be converted that converts to the new object. Name the method by prepending “as” to the class of the object.

class Collection {
  asSet() {

  }
}

class Number {
  asFloat() {

  }
}

Converter Constructor Method

You need to implement Conversion to a new kind of object.

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

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

class Date {
  constructor(string) {
    this._string = string;
  }
}

Query Method

A composed method has had to execute a boolean expression.

How do you represent testing a property of an object?

Provide a method that returns a Boolean. Name it by prefacing the property name with a form of "be" - is, was, will etc e.g

isNil
isControlWanted
isEmpty

class Switch {
  constructor() {
    this._status = 'off';
  }

  makeOn() {
    this._status = 'on';
  }

  makeOff() {
    this._status = 'off'
  }

  isOn() {
    return this._status === 'on' ? true : false;
  }

  isOff() {
    return this._status === 'off' ? true : false;
  }

  status() {
    return this._status
  }
}

const smallSwitch = new Switch()

smallSwitch.makeOn()
const smallSwitchIsOn = smallSwitch.isOn()
// => true
smallSwitch.makeOff()
const smallSwitchIsOn = smallSwitch.isOff()
// => true
smallSwitch.status()
// => off

Comparing Method

How do you order objects with respect to each other?

Put comparing methods in a protocol called 'comparing'.

Reversing Method

A composed method may not read right because messages are going to too many receivers. You may have a Cascade that doesn't look quite right because several different objects need to receive messages.

How do you code a smooth flow of messages?

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

// TODO

Method Object

You have a method that does not simplify well with Composed Method

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

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

class Obligation {
  send_task(task, job) {
    let [not_processed, processed, copied, executed] = []
  }
  // Using composed method we get a method like this
  prepareTask(task, job, notProcessed, processed, copied, executed) {

  }
}

// Method Object
class TaskSender {
  constructor(obligation, task, job) {
    this._obligation = obligation;
    this._task = task;
    this._job = job
  };

  get obligation() {
    return this._obligation
  };

  set obligation(obligation) {
    this._obligation = obligation
  };

  get task() {
    return this._task
  };

  set task(task) {
    this._task = task
  };

  get job() {
    return this._job
  };

  set job(job) {
    this._job = job
  };

  get not_processed() {
    return this._not_processed
  };

  set not_processed(not_processed) {
    this._not_processed = not_processed
  };

  get processed() {
    return this._processed
  };

  set processed(processed) {
    this._processed = processed
  };

  get copied() {
    return this._copied
  };

  set copied(copied) {
    this._copied = copied
  };

  get executed() {
    return this._executed
  };

  set executed(executed) {
    this._executed = executed
  };

  get compute() {

  }
}

class Obligation {
  sendTask(task, job) {
    const taskSender = new TaskSender(task, job);
    return taskSender.compute();
  }
}

Execute Around Method

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

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

Method Comment

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

Here are examples of information that can be difficult to communicate solely through the code:

Method Dependencies

Sometimes one method must be invoked before another can execute correctly. A comment can warn the reader not to invoke one without the other. Sometimes you can use Composed Method or Execute Around Method to communicate the same information.

To-do

I often write comments while I am prototyping to remind myself of some thought I don't want to lose. 'Look at using a Dictionary later for efficiency', for example.

When I reconsider the thought later, I delete the comment after choosing whether to follow it.

Reasons for Change

Particularly on base classes, if you need to change something, the reason for the chance is often not immediately apparent in the code. This often occurs when changing a method supplied by a Smalltalk vendor. A comment helps a reader understand why you did what you did if you can't make the code say it.

Messages

Choosing Messages

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.

let responsible = (entry.kindOf(Film) ? entry.producer : entry.author);

// Choosing message
responsible = entry.responsible;

class Film {
  get responsible() {
    return producer
  }
};

class Entry {
  get responsible() {
    return author
  }
}

Decomposing Message

You are using a Message to break a computation into parts.

How do you invoke parts of a computation?

Send several messages to 'self'

class Controller {
  controlInitialise() {
    console.log('Controller initialising...');
  }

  controlLoop() {
    console.log('Controller looping: 1, 2, 3');
  }

  controlTerminate() {
    console.log('Controller terminated');
  }

  controlActivity() {
    this.controlInitialise();
    this.controlLoop();
    this.controlTerminate();
  }
}

const controller = new Controller();

controller.controlActivity();
// => Controller initialising...
// => Controller looping: 1, 2, 3
// => Controller terminated

Intention Revealing Message

You are using a Message to invoke a computation. You may be hiding the use of Pluggable Behaviour.

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

The one that separates intention (what you want done) from implementation (how it is done) communicates better to a person.

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

class ParagraphEditor {
  highlight(rectangle) {
    return reverse(rectangle)
  }
}

class Collection {
  isEmpty() {
    return size.zero ? true : false;
  }
};

class Number {
  get reciprocal() {
    return 1 / this
  }
};

Intention Revealing Selector

How do you name a method?

Name methods after what it is supposed to accomplish and leave "how" to the various method bodies.

class Collection {
  // ...
  searchFor(value) {

  }
};

class Collection {
  // ...
  includes(value) {

  }
}

Dispatched Interpretation

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

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

// TODO

Extending Super

How do you add to a superclass implementation of a method?

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

class Displayable {
	constructor() {
		this._display = 'Displaying...';
	}

	display() {
		console.log(this._display)
	}

}

class BorderedFigure extends Displayable {
	constructor() {
    super()
    this._border = 'Border';
  }

  display() {
    super.display();
    return this.displayBorder();
  }

	displayBorder() {
		console.log(`with ${this._border}`)
	}
}

const borderedFigure = new BorderedFigure();

borderedFigure.display();

Modifying Super

How do you change part of the behaviour of a superclass method without modifying it?

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

class IntegerAdder {
  constructor() {
    this._sum = this.defaultSum();
    this._count = this.defaultCount();
  };

  get defaultSum() {
    return 0;
  };

  get defaultCount() {
    return 0;
  }
};

class FloatAdder {
  get defaultSum() {
    return 0.0;
  }
}

Simple Delegation

A composed method needs work done by another object. A message invokes computation in another object.

How do you invoke a disinterested delegate?

Delegate messages unchanged.

unixer-asuo/small-talk-best-practices-javascript

Smalltalk Best Practice Patterns - Javascript

Contents

Patterns from the book

Behaviour

Methods

Messages

State

Instance Variables

Temporary Variables

Collections

Classes

Formatting

Patterns

Behaviour

Composed Method

Constructor Method

Constructor Parameter Method

Shortcut Constructor Method

Conversion

Converter Method

Converter Constructor Method

Query Method

Comparing Method

Reversing Method

Method Object

Execute Around Method

Method Comment

Method Dependencies

To-do

Reasons for Change

Messages

Choosing Messages

Decomposing Message

Intention Revealing Message

Intention Revealing Selector

Dispatched Interpretation

Extending Super

Modifying Super

Simple Delegation