anchor.diff:  
   *I see that instead of `events.emit(...)`, now the class just uses `emit(...)`. And the same with `#on`.*
   
  -Very observant! `Observable` adds three methods to classes which mix it in:
  +Very observant! `Observable` adds four methods to classes which mix it in:
   
   - `#on`, to quickly attach single-event handlers on the object.
   - `#emit`, a private method for conveniently emitting events inside the class.
   - `#events`, to access the `Emitter` object.
  +- `#with_subscription_scope`, which we'll talk about later.
   
   *That's not a lot of methods added.*
   
   Nope! That's intentional. These are your classes, and I don't want to clutter up your API unnecessarily. `#on` and `#emit` are provided as conveniences for common actions. Anything else you need, you can get to via the `Emitter` returned from `#events`.
   
  +=== Constraining event types
  +
   *I see that un-handled events are just ignored. Doesn't that make it easy to miss events because of a typo in the name?*
   
   Yeah, it kinda does. In order to help with that, there's an alternative kind of emitter: a `ManifestEmitter`. And to go along with it, there's a `ManifestlyObservable` mixin module. We customize the module with a list of known event names. Then if anything tries to either emit or subscribe to an unknown event name, the emitter outputs a warning.
  
positive.code: <%= File.read("examples/include_manifestly_observable.rb") %>
  ```
  
  *I'm still a little confused about `#on`. Is that just another way to add an observer?*
  
  `#on` is really just a shortcut. Often we don't want to attach a whole observer to an observable object. We just want to trigger a particular block of code to be run when a specific event is detected. So `#on` makes it easy to hook up a block of code to a single event.
  
negative.code: 
  For convenience, the event name, source, and arguments are all bundled into an `Event` object before being disseminated to observers.
  
  === Making an object observable
  
  *OK, say I have an object that I want to make observable. How would I go about that?*
  
  Well, the no-magic way might go something like this:
  