anchor.diff:  import 'dart:async';
   import 'dart:convert';
   
  +/**
  + * Defines a class which contains services and handles their communication.
  + */
  +class Services {
  +  final String _workerPath = 'services/services_isolate.dart';
  +  ServiceHandler _handler;
  +  SendPort _sendPort;
  +  final ReceivePort _receivePort = new ReceivePort();
   
  -class Services {
  -  final String workerPath = 'services/services_isolate.dart';
  -  ServiceHandler handler;
  -  SendPort sendPort;
  -  final ReceivePort receivePort = new ReceivePort();
  +  void ping() {
  +    TestMessage command = new TestMessage.yell('Marco');
  +    print("Sending '$command'");
  +    _handler.sendCommand(command);
  +  }
   
     Services() {
  -    handler = new ServiceHandler.owner(receivePort);
  -    handler.listenForSendPort(workerPath).then((_){
  -      new Timer.periodic(const Duration(seconds: 1), (t) {
  -        print("Sending 'Marco!'");
  -        TestMessage command = new TestMessage.yell('Marco');
  -        handler.sendCommand(command);
  -      });
  +    _handler = new ServiceHandler.owner(_receivePort);
  +
  +    // TODO(ericarnold): Provide an onReady handler
  +    _handler.listenForSendPort(_workerPath).then((_){
  +      ping();
       });
     }
   }
   
  +/**
  + * Defines a handler for isolates which is unified between worker and origin.
  + */
  +class ServiceHandler {
  +  SendPort _sendPort;
  +  ReceivePort _receivePort;
  +  bool _isWorker = false;
   
  -class ServiceHandler {
  -  SendPort sendPort;
  -  ReceivePort receivePort;
  +  ServiceHandler.worker(this._receivePort, this._sendPort) {
  +    _isWorker = true;
  +    _receivePort.listen((command) {
  +      performCommand(command);
  +    });
  +  }
  +
  +  ServiceHandler.owner(this._receivePort);
   
     Future listenForSendPort(String workerPath) {
       Completer completer = new Completer();
  -    receivePort.listen((parameter) {
  -      if (sendPort == null) {
  -        sendPort = parameter;
  +    _receivePort.listen((parameter) {
  +      if (_sendPort == null) {
  +        _sendPort = parameter;
           completer.complete();
         } else {
           performCommand(parameter);
  
positive.code: 
      Uri workerUri = Uri.parse(workerPath);
  
      Isolate.spawnUri(workerUri, [], receivePort.sendPort);
      return completer.future;
    }
  
    bool isWorker = false;
    ServiceHandler.worker(this.receivePort, this.sendPort) {
      isWorker = true;
      receivePort.listen((command) {
        performCommand(command);
      });
    }
  
    ServiceHandler.owner(this.receivePort);
  
    sendCommand(Command command) {
      sendPort.send({
          "response": false,
          "id": command.commandId,
          "data": command.serialize()});
  
negative.code:     }
    }
  
    void handleCommand(Command command, bool isResponse) {
      if (isResponse) {
        // TODO(ericarnold): Complete a future (returned by sendCommand)/
        print("response: " + command.toString());
      } else {
        sendResponse(command);
      }
    }
  
    void sendResponse(Command command) {
      Command responseObject = command.respond();
      _sendPort.send({
          "response": true,
          "id": responseObject.commandId,
          "data": responseObject.serialize()});
    }
  }
  
  /**
   * Defines an abstract class whose interface is identical at the origin and the
   * worker, but which provides functionality only on the responder and acts as a
   * simple proxy on the other end.
   */
  abstract class Command {
    Command();
    Command.serialized(String serializedData);
  