diff --git a/ember_debug/adapters/basic.js b/ember_debug/adapters/basic.js
index 5fe106018e..08e1cb5886 100644
--- a/ember_debug/adapters/basic.js
+++ b/ember_debug/adapters/basic.js
@@ -1,15 +1,12 @@
 /* globals requireModule */
-var Ember = window.Ember;
-var computed = Ember.computed;
-var $ = Ember.$;
-var RSVP = Ember.RSVP;
-var Promise = RSVP.Promise;
-
-export default Ember.Object.extend({
-  init: function() {
-    var self = this;
-    RSVP.resolve(this.connect(), 'ember-inspector').then(function() {
-      self.onConnectionReady();
+const Ember = window.Ember;
+const { $, A, computed, RSVP, Object: EmberObject } = Ember;
+const { Promise, resolve } = RSVP;
+
+export default EmberObject.extend({
+  init() {
+    resolve(this.connect(), 'ember-inspector').then(() => {
+      this.onConnectionReady();
     }, null, 'ember-inspector');
   },
 
@@ -24,11 +21,11 @@ export default Ember.Object.extend({
     return requireModule('ember-debug/config')['default'].environment;
   }),
 
-  debug: function() {
+  debug() {
     return console.debug.apply(console, arguments);
   },
 
-  log: function() {
+  log() {
     return console.log.apply(console, arguments);
   },
 
@@ -37,7 +34,7 @@ export default Ember.Object.extend({
    *
    * @method warn
    */
-  warn: function() {
+  warn() {
     return console.warn.apply(console, arguments);
   },
 
@@ -46,7 +43,7 @@ export default Ember.Object.extend({
 
     @param {Object} type the message to the send
   */
-  sendMessage: function(/* options */) {},
+  sendMessage(/* options */) {},
 
   /**
     Register functions to be called
@@ -54,7 +51,7 @@ export default Ember.Object.extend({
 
     @param {Function} callback
   */
-  onMessageReceived: function(callback) {
+  onMessageReceived(callback) {
     this.get('_messageCallbacks').pushObject(callback);
   },
 
@@ -69,12 +66,12 @@ export default Ember.Object.extend({
 
     @param {DOM Element} elem
   */
-  inspectElement: function(/* elem */) {},
+  inspectElement(/* elem */) {},
 
-  _messageCallbacks: Ember.computed(function() { return Ember.A(); }).property(),
+  _messageCallbacks: computed(function() { return A(); }),
 
-  _messageReceived: function(message) {
-    this.get('_messageCallbacks').forEach(function(callback) {
+  _messageReceived(message) {
+    this.get('_messageCallbacks').forEach(callback => {
       callback.call(null, message);
     });
   },
@@ -92,7 +89,7 @@ export default Ember.Object.extend({
    * @method handleError
    * @param {Error} error
    */
-  handleError: function(error) {
+  handleError(error) {
     if (this.get('environment') === 'production') {
       if (error && error instanceof Error) {
         error = 'Error message: ' + error.message + '\nStack trace: ' + error.stack;
@@ -114,14 +111,13 @@ export default Ember.Object.extend({
 
     @return {Promise}
   */
-  connect: function() {
-    var self = this;
-    return new Promise(function(resolve, reject) {
-      $(function() {
-        if (self.isDestroyed) { reject(); }
-        self.interval = setInterval(function() {
+  connect() {
+    return new Promise((resolve, reject) => {
+      $(() => {
+        if (this.isDestroyed) { reject(); }
+        this.interval = setInterval(function() {
           if (document.documentElement.dataset.emberExtension) {
-            clearInterval(self.interval);
+            clearInterval(this.interval);
             resolve();
           }
         }, 10);
@@ -129,15 +125,15 @@ export default Ember.Object.extend({
     }, 'ember-inspector');
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this._super();
     clearInterval(this.interval);
   },
 
   _isReady: false,
-  _pendingMessages: computed(function() { return Ember.A(); }).property(),
+  _pendingMessages: computed(function() { return A(); }),
 
-  send: function(options) {
+  send(options) {
     if (this._isReady) {
       this.sendMessage.apply(this, arguments);
     } else {
@@ -149,13 +145,10 @@ export default Ember.Object.extend({
     Called when the connection is set up.
     Flushes the pending messages.
   */
-  onConnectionReady: function() {
+  onConnectionReady() {
     // Flush pending messages
-    var self = this;
-    var messages = this.get('_pendingMessages');
-    messages.forEach(function(options) {
-      self.sendMessage(options);
-    });
+    const messages = this.get('_pendingMessages');
+    messages.forEach(options => this.sendMessage(options));
     messages.clear();
     this._isReady = true;
   }
diff --git a/ember_debug/adapters/bookmarklet.js b/ember_debug/adapters/bookmarklet.js
index 84990af218..a5d62873de 100644
--- a/ember_debug/adapters/bookmarklet.js
+++ b/ember_debug/adapters/bookmarklet.js
@@ -1,32 +1,31 @@
 import BasicAdapter from "./basic";
-var Ember = window.Ember;
-var $ = Ember.$;
+const Ember = window.Ember;
+const { $ } = Ember;
 
 export default BasicAdapter.extend({
-  init: function() {
+  init() {
     this._super();
     this._listen();
   },
 
-  sendMessage: function(options) {
+  sendMessage(options) {
     options = options || {};
     window.emberInspector.w.postMessage(options, window.emberInspector.url);
   },
 
-  _listen: function() {
-    var self = this;
-    window.addEventListener('message', function(e) {
+  _listen() {
+    window.addEventListener('message', (e) => {
       if (e.origin !== window.emberInspector.url) {
         return;
       }
-      var message = e.data;
+      const message = e.data;
       if (message.from === 'devtools') {
-        self._messageReceived(message);
+        this._messageReceived(message);
       }
     });
 
-    $(window).on('unload', function() {
-      self.sendMessage({
+    $(window).on('unload', () => {
+      this.sendMessage({
         unloading: true
       });
     });
diff --git a/ember_debug/adapters/chrome.js b/ember_debug/adapters/chrome.js
index 36ce6e6825..770877a9f4 100644
--- a/ember_debug/adapters/chrome.js
+++ b/ember_debug/adapters/chrome.js
@@ -1,42 +1,41 @@
 import BasicAdapter from "./basic";
-var Ember = window.Ember;
+const Ember = window.Ember;
+const { computed, run } = Ember;
 
-var ChromeAdapter = BasicAdapter.extend({
-  connect: function() {
-    var channel = this.get('_channel');
-    var self = this;
-    return this._super.apply(this, arguments).then(function() {
+export default BasicAdapter.extend({
+  connect() {
+    const channel = this.get('_channel');
+    return this._super(...arguments).then(() => {
       window.postMessage('debugger-client', [channel.port2], '*');
-      self._listen();
+      this._listen();
     }, null, 'ember-inspector');
   },
 
-  sendMessage: function(options) {
+  sendMessage(options) {
     options = options || {};
     this.get('_chromePort').postMessage(options);
   },
 
-  inspectElement: function(elem) {
+  inspectElement(elem) {
     /* globals inspect */
     inspect(elem);
   },
 
-  _channel: Ember.computed(function() {
+  _channel: computed(function() {
     return new MessageChannel();
-  }).property().readOnly(),
+  }).readOnly(),
 
-  _chromePort: Ember.computed(function() {
+  _chromePort: computed(function() {
     return this.get('_channel.port1');
-  }).property().readOnly(),
+  }).readOnly(),
 
-  _listen: function() {
-    var self = this,
-        chromePort = this.get('_chromePort');
+  _listen() {
+    let chromePort = this.get('_chromePort');
 
     chromePort.addEventListener('message', function(event) {
-      var message = event.data;
-      Ember.run(function() {
-        self._messageReceived(message);
+      const message = event.data;
+      run(() => {
+        this._messageReceived(message);
       });
     });
 
@@ -44,5 +43,3 @@ var ChromeAdapter = BasicAdapter.extend({
 
   }
 });
-
-export default ChromeAdapter;
diff --git a/ember_debug/adapters/firefox.js b/ember_debug/adapters/firefox.js
index 2f8eb7827b..262615592b 100644
--- a/ember_debug/adapters/firefox.js
+++ b/ember_debug/adapters/firefox.js
@@ -1,14 +1,15 @@
 /* eslint no-empty:0 */
 import BasicAdapter from "./basic";
-var Ember = window.Ember;
+const Ember = window.Ember;
+const { run } = Ember;
 
-var FirefoxAdapter = BasicAdapter.extend({
-  init: function() {
+export default BasicAdapter.extend({
+  init() {
     this._super();
     this._listen();
   },
 
-  debug: function() {
+  debug() {
     // WORKAROUND: temporarily workaround issues with firebug console object:
     // - https://github.com/tildeio/ember-extension/issues/94
     // - https://github.com/firebug/firebug/pull/109
@@ -17,7 +18,7 @@ var FirefoxAdapter = BasicAdapter.extend({
       this._super.apply(this, arguments);
     } catch(e) { }
   },
-  log: function() {
+  log() {
     // WORKAROUND: temporarily workaround issues with firebug console object:
     // - https://github.com/tildeio/ember-extension/issues/94
     // - https://github.com/firebug/firebug/pull/109
@@ -27,26 +28,25 @@ var FirefoxAdapter = BasicAdapter.extend({
     } catch(e) { }
   },
 
-  sendMessage: function(options) {
+  sendMessage(options) {
     options = options || {};
-    var event = document.createEvent("CustomEvent");
+    let event = document.createEvent("CustomEvent");
     event.initCustomEvent("ember-debug-send", true, true, options);
     document.documentElement.dispatchEvent(event);
   },
 
-  inspectElement: function(elem) {
+  inspectElement(elem) {
     this.sendMessage({
       type: 'view:devtools:inspectDOMElement',
       elementSelector: "#" + elem.getAttribute('id')
     });
   },
 
-  _listen: function() {
-    var self = this;
+  _listen() {
 
     window.addEventListener('ember-debug-receive', function(event) {
       var message = event.detail;
-      Ember.run(function() {
+      run(() => {
         // FIX: needed to fix permission denied exception on Firefox >= 30
         // - https://github.com/emberjs/ember-inspector/issues/147
         // - https://blog.mozilla.org/addons/2014/04/10/changes-to-unsafewindow-for-the-add-on-sdk/
@@ -59,11 +59,10 @@ var FirefoxAdapter = BasicAdapter.extend({
         default:
           throw new Error("ember-debug-receive: string or object expected");
         }
-        self._messageReceived(message);
+        this._messageReceived(message);
       });
     });
   }
 
 });
 
-export default FirefoxAdapter;
diff --git a/ember_debug/adapters/websocket.js b/ember_debug/adapters/websocket.js
index 883b0db41e..c682a11dd1 100644
--- a/ember_debug/adapters/websocket.js
+++ b/ember_debug/adapters/websocket.js
@@ -1,51 +1,46 @@
 import BasicAdapter from "./basic";
-var Ember = window.Ember;
-var computed = Ember.computed;
-var Promise = Ember.RSVP.Promise;
-var $ = Ember.$;
+const Ember = window.Ember;
+const { $, computed, run, RSVP: { Promise } } = Ember;
 
-var WebsocketAdapter = BasicAdapter.extend({
+export default BasicAdapter.extend({
 
-  sendMessage: function(options) {
+  sendMessage(options) {
     options = options || {};
     this.get('socket').emit('emberInspectorMessage', options);
   },
 
   socket: computed(function() {
     return window.EMBER_INSPECTOR_CONFIG.remoteDebugSocket;
-  }).property(),
+  }),
 
-  _listen: function() {
-    var self = this;
+  _listen() {
     this.get('socket').on('emberInspectorMessage', function(message) {
-      Ember.run(function() {
-        self._messageReceived(message);
+      run(() => {
+        this._messageReceived(message);
       });
     });
   },
 
-  _disconnect: function() {
+  _disconnect() {
     this.get('socket').removeAllListeners("emberInspectorMessage");
   },
 
-  connect: function() {
-    var self = this;
-    return new Promise(function(resolve, reject) {
-      $(function() {
-        if (self.isDestroyed) { reject(); }
-        var EMBER_INSPECTOR_CONFIG = window.EMBER_INSPECTOR_CONFIG;
+  connect() {
+    return new Promise((resolve, reject) => {
+      $(() => {
+        if (this.isDestroyed) { reject(); }
+        const EMBER_INSPECTOR_CONFIG = window.EMBER_INSPECTOR_CONFIG;
         if (typeof EMBER_INSPECTOR_CONFIG === 'object' && EMBER_INSPECTOR_CONFIG.remoteDebugSocket) {
           resolve();
         }
       });
-    }).then(function() {
-      self._listen();
+    }).then(() => {
+      this._listen();
     });
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this._disconnect();
   }
 });
 
-export default WebsocketAdapter;
diff --git a/ember_debug/addons/ember-new-computed/index.js b/ember_debug/addons/ember-new-computed/index.js
index 68f8f2b4ef..d89ac7096b 100644
--- a/ember_debug/addons/ember-new-computed/index.js
+++ b/ember_debug/addons/ember-new-computed/index.js
@@ -1,21 +1,21 @@
 import canUseNewSyntax from './utils/can-use-new-syntax';
 
-var Ember = window.Ember;
-var computed = Ember.computed;
+const Ember = window.Ember;
+const { computed } = Ember;
 
 export default function() {
-  var polyfillArguments = [];
-  var config = arguments[arguments.length - 1];
+  let polyfillArguments = [];
+  let config = arguments[arguments.length - 1];
 
   if (typeof config === 'function' || canUseNewSyntax) {
     return computed.apply(this, arguments);
   }
 
-  for (var i = 0, l = arguments.length - 1; i < l; i++) {
+  for (let i = 0, l = arguments.length - 1; i < l; i++) {
     polyfillArguments.push(arguments[i]);
   }
 
-  var func;
+  let func;
   if (config.set) {
     func = function(key, value) {
       if (arguments.length > 1) {
diff --git a/ember_debug/addons/ember-new-computed/utils/can-use-new-syntax.js b/ember_debug/addons/ember-new-computed/utils/can-use-new-syntax.js
index fcbc925558..e2ad85da56 100644
--- a/ember_debug/addons/ember-new-computed/utils/can-use-new-syntax.js
+++ b/ember_debug/addons/ember-new-computed/utils/can-use-new-syntax.js
@@ -1,8 +1,9 @@
-var Ember = window.Ember;
-var supportsSetterGetter;
+const Ember = window.Ember;
+const { computed } = Ember;
+let supportsSetterGetter;
 
 try {
-  Ember.computed({
+  computed({
     set: function() { },
     get: function() { }
   });
diff --git a/ember_debug/container-debug.js b/ember_debug/container-debug.js
index aea7fcef8e..c60ab52d6a 100644
--- a/ember_debug/container-debug.js
+++ b/ember_debug/container-debug.js
@@ -1,8 +1,7 @@
 import PortMixin from "ember-debug/mixins/port-mixin";
-var Ember = window.Ember;
-var EmberObject = Ember.Object;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
+const Ember = window.Ember;
+const { Object: EmberObject, computed } = Ember;
+const { oneWay } = computed;
 
 export default EmberObject.extend(PortMixin, {
   namespace: null,
@@ -11,9 +10,9 @@ export default EmberObject.extend(PortMixin, {
   application: oneWay('namespace.application').readOnly(),
   objectInspector: oneWay('namespace.objectInspector').readOnly(),
 
-  container: computed(function() {
+  container: computed('application', function() {
     return this.get('application.__container__');
-  }).property('application'),
+  }),
 
   portNamespace: 'container',
 
@@ -24,29 +23,30 @@ export default EmberObject.extend(PortMixin, {
       'resolver-for-debugging',
       'event_dispatcher'
     ];
-  }).property(),
+  }),
 
-  typeFromKey: function(key) {
+  typeFromKey(key) {
     return key.split(':').shift();
   },
 
-  nameFromKey: function(key) {
+  nameFromKey(key) {
     return key.split(':').pop();
   },
 
-  shouldHide: function(type) {
+  shouldHide(type) {
     return type[0] === '-' || this.get('TYPES_TO_SKIP').indexOf(type) !== -1;
   },
 
-  instancesByType: function() {
-    var key, instancesByType = {};
-    var cache = this.get('container').cache;
+  instancesByType() {
+    let key;
+    let instancesByType = {};
+    let cache = this.get('container').cache;
     // Detect if InheritingDict (from Ember < 1.8)
     if (typeof cache.dict !== 'undefined' && typeof cache.eachLocal !== 'undefined') {
       cache = cache.dict;
     }
     for (key in cache) {
-      var type = this.typeFromKey(key);
+      const type = this.typeFromKey(key);
       if (this.shouldHide(type)) { continue; }
       if (instancesByType[type] === undefined) {
         instancesByType[type] = [];
@@ -59,37 +59,38 @@ export default EmberObject.extend(PortMixin, {
     return instancesByType;
   },
 
-  getTypes: function() {
-    var key, types = [];
-    var instancesByType = this.instancesByType();
+  getTypes() {
+    let key;
+    let types = [];
+    const instancesByType = this.instancesByType();
     for (key in instancesByType) {
       types.push({ name: key, count: instancesByType[key].length });
     }
     return types;
   },
 
-  getInstances: function(type) {
-    var instances = this.instancesByType()[type];
+  getInstances(type) {
+    const instances = this.instancesByType()[type];
     if (!instances) {
       return null;
     }
-    return instances.map(function(item) {
+    return instances.map((item) => {
       return {
         name: this.nameFromKey(item.fullName),
         fullName: item.fullName,
         inspectable: this.get('objectInspector').canSend(item.instance)
       };
-    }.bind(this));
+    });
   },
 
   messages: {
-    getTypes: function() {
+    getTypes() {
       this.sendMessage('types', {
         types: this.getTypes()
       });
     },
-    getInstances: function(message) {
-      var instances = this.getInstances(message.containerType);
+    getInstances(message) {
+      let instances = this.getInstances(message.containerType);
       if (instances) {
         this.sendMessage('instances', {
           instances: instances,
@@ -101,8 +102,8 @@ export default EmberObject.extend(PortMixin, {
         });
       }
     },
-    sendInstanceToConsole: function(message) {
-      var instance = this.get('container').lookup(message.name);
+    sendInstanceToConsole(message) {
+      const instance = this.get('container').lookup(message.name);
       this.get('objectToConsole').sendValueToConsole(instance);
     }
   }
diff --git a/ember_debug/data-debug.js b/ember_debug/data-debug.js
index a32d1ca046..b882b873b5 100644
--- a/ember_debug/data-debug.js
+++ b/ember_debug/data-debug.js
@@ -1,7 +1,10 @@
 import PortMixin from 'ember-debug/mixins/port-mixin';
-var Ember = window.Ember;
-var DataDebug = Ember.Object.extend(PortMixin, {
-  init: function() {
+const Ember = window.Ember;
+const { Object: EmberObject, computed, guidFor, A } = Ember;
+const { alias } = computed;
+
+export default EmberObject.extend(PortMixin, {
+  init() {
     this._super();
     this.sentTypes = {};
     this.sentRecords = {};
@@ -13,17 +16,17 @@ var DataDebug = Ember.Object.extend(PortMixin, {
   releaseTypesMethod: null,
   releaseRecordsMethod: null,
 
-  adapter: Ember.computed(function() {
-    var container = this.get('application').__container__;
+  adapter: computed('application', function() {
+    const container = this.get('application').__container__;
 
     // dataAdapter:main is deprecated
     return (this._resolve('data-adapter:main') && container.lookup('data-adapter:main')) ||
     (this._resolve('dataAdapter:main') && container.lookup('dataAdapter:main'));
-  }).property('application'),
+  }),
 
-  _resolve: function(name) {
-    var container = this.get('application').__container__;
-    var registry = this.get('application.registry');
+  _resolve(name) {
+    const container = this.get('application').__container__;
+    let registry = this.get('application.registry');
     if (registry) {
       // Ember >= 1.11
       return registry.resolve(name);
@@ -36,34 +39,29 @@ var DataDebug = Ember.Object.extend(PortMixin, {
 
   namespace: null,
 
-  port: Ember.computed.alias('namespace.port'),
-  application: Ember.computed.alias('namespace.application'),
-  objectInspector: Ember.computed.alias('namespace.objectInspector'),
+  port: alias('namespace.port'),
+  application: alias('namespace.application'),
+  objectInspector: alias('namespace.objectInspector'),
 
   portNamespace: 'data',
 
-  modelTypesAdded: function(types) {
-    var self = this, typesToSend;
-    typesToSend = types.map(function(type) {
-      return self.wrapType(type);
-    });
+  modelTypesAdded(types) {
+    let typesToSend;
+    typesToSend = types.map(type => this.wrapType(type));
     this.sendMessage('modelTypesAdded', {
       modelTypes: typesToSend
     });
   },
 
-  modelTypesUpdated: function(types) {
-    var self = this;
-    var typesToSend = types.map(function(type) {
-      return self.wrapType(type);
-    });
-    self.sendMessage('modelTypesUpdated', {
+  modelTypesUpdated(types) {
+    let typesToSend = types.map(type => this.wrapType(type));
+    this.sendMessage('modelTypesUpdated', {
       modelTypes: typesToSend
     });
   },
 
-  wrapType: function(type) {
-    var objectId = Ember.guidFor(type.object);
+  wrapType(type) {
+    const objectId = guidFor(type.object);
     this.sentTypes[objectId] = type;
 
     return {
@@ -75,46 +73,41 @@ var DataDebug = Ember.Object.extend(PortMixin, {
   },
 
 
-  recordsAdded: function(recordsReceived) {
-    var self = this, records;
-    records = recordsReceived.map(function(record) {
-      return self.wrapRecord(record);
-    });
-    self.sendMessage('recordsAdded', {
+  recordsAdded(recordsReceived) {
+    let records;
+    records = recordsReceived.map(record => this.wrapRecord(record));
+    this.sendMessage('recordsAdded', {
       records: records
     });
   },
 
-  recordsUpdated: function(recordsReceived) {
-    var self = this;
-    var records = recordsReceived.map(function(record) {
-      return self.wrapRecord(record);
-    });
-    self.sendMessage('recordsUpdated', {
+  recordsUpdated(recordsReceived) {
+    let records = recordsReceived.map(record => this.wrapRecord(record));
+    this.sendMessage('recordsUpdated', {
       records: records
     });
   },
 
-  recordsRemoved: function(idx, count) {
+  recordsRemoved(idx, count) {
     this.sendMessage('recordsRemoved', {
       index: idx,
       count: count
     });
   },
 
-  wrapRecord: function(record) {
-    var objectId = Ember.guidFor(record.object);
-    var columnValues = {};
-    var searchKeywords = [];
+  wrapRecord(record) {
+    const objectId = guidFor(record.object);
+    let columnValues = {};
+    let searchKeywords = [];
     this.sentRecords[objectId] = record;
     // make objects clonable
-    for (var i in record.columnValues) {
+    for (let i in record.columnValues) {
       columnValues[i] = this.get('objectInspector').inspect(record.columnValues[i]);
     }
     // make sure keywords can be searched and clonable
-    searchKeywords = Ember.A(record.searchKeywords).filter(function(keyword) {
-      return (typeof keyword === 'string' || typeof keyword === 'number');
-    });
+    searchKeywords = A(record.searchKeywords).filter(keyword =>
+      (typeof keyword === 'string' || typeof keyword === 'number')
+    );
     return {
       columnValues: columnValues,
       searchKeywords: searchKeywords,
@@ -124,7 +117,7 @@ var DataDebug = Ember.Object.extend(PortMixin, {
     };
   },
 
-  releaseTypes: function() {
+  releaseTypes() {
     if (this.releaseTypesMethod) {
       this.releaseTypesMethod();
       this.releaseTypesMethod = null;
@@ -132,7 +125,7 @@ var DataDebug = Ember.Object.extend(PortMixin, {
     }
   },
 
-  releaseRecords: function() {
+  releaseRecords() {
     if (this.releaseRecordsMethod) {
       this.releaseRecordsMethod();
       this.releaseRecordsMethod = null;
@@ -140,67 +133,57 @@ var DataDebug = Ember.Object.extend(PortMixin, {
     }
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this._super();
     this.releaseRecords();
     this.releaseTypes();
   },
 
   messages: {
-    checkAdapter: function() {
+    checkAdapter() {
       this.sendMessage('hasAdapter', { hasAdapter: !!this.get('adapter') });
     },
 
-    getModelTypes: function() {
-      var self = this;
+    getModelTypes() {
       this.releaseTypes();
-      this.releaseTypesMethod = this.get('adapter').watchModelTypes(
-        function(types) {
-          self.modelTypesAdded(types);
-        }, function(types) {
-        self.modelTypesUpdated(types);
+      this.releaseTypesMethod = this.get('adapter').watchModelTypes(types => {
+        this.modelTypesAdded(types);
+      }, types => {
+        this.modelTypesUpdated(types);
       });
     },
 
-    releaseModelTypes: function() {
+    releaseModelTypes() {
       this.releaseTypes();
     },
 
-    getRecords: function(message) {
-      var type = this.sentTypes[message.objectId], self = this;
+    getRecords(message) {
+      const type = this.sentTypes[message.objectId];
       this.releaseRecords();
 
-      let typeOrName;
-      if (this.get('adapter.acceptsModelName')) {
-        // Ember >= 1.3
-        typeOrName = type.name;
-      } else {
-        // support for legacy Ember < 1.3
-        typeOrName = type.object;
-      }
-      var releaseMethod = this.get('adapter').watchRecords(typeOrName,
-        function(recordsReceived) {
-          self.recordsAdded(recordsReceived);
+      const releaseMethod = this.get('adapter').watchRecords(type.object,
+        (recordsReceived) => {
+          this.recordsAdded(recordsReceived);
         },
-        function(recordsUpdated) {
-          self.recordsUpdated(recordsUpdated);
+        (recordsUpdated) => {
+          this.recordsUpdated(recordsUpdated);
         },
-        function() {
-          self.recordsRemoved.apply(self, arguments);
+        () => {
+          this.recordsRemoved(...arguments);
         }
       );
       this.releaseRecordsMethod = releaseMethod;
     },
 
-    releaseRecords: function() {
+    releaseRecords() {
       this.releaseRecords();
     },
 
-    inspectModel: function(message) {
+    inspectModel(message) {
       this.get('objectInspector').sendObject(this.sentRecords[message.objectId].object);
     },
 
-    getFilters: function() {
+    getFilters() {
       this.sendMessage('filters', {
         filters: this.get('adapter').getFilters()
       });
@@ -208,4 +191,3 @@ var DataDebug = Ember.Object.extend(PortMixin, {
   }
 });
 
-export default DataDebug;
diff --git a/ember_debug/deprecation-debug.js b/ember_debug/deprecation-debug.js
index 6794fe92bd..eb6044a75b 100644
--- a/ember_debug/deprecation-debug.js
+++ b/ember_debug/deprecation-debug.js
@@ -1,12 +1,9 @@
 import PortMixin from "ember-debug/mixins/port-mixin";
 import SourceMap from "ember-debug/libs/source-map";
-var Ember = window.Ember;
-var EmberObject = Ember.Object;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
-var run = Ember.run;
-var guidFor = Ember.guidFor;
-var RSVP = Ember.RSVP;
+const Ember = window.Ember;
+const { Object: EmberObject, computed, guidFor, run, RSVP, A } = Ember;
+const { resolve, all } = RSVP;
+const { oneWay } = computed;
 
 export default EmberObject.extend(PortMixin, {
   portNamespace: 'deprecation',
@@ -16,24 +13,24 @@ export default EmberObject.extend(PortMixin, {
   adapter: oneWay('port.adapter').readOnly(),
 
   deprecations: computed(function() {
-    return Ember.A();
-  }).property(),
+    return A();
+  }),
 
   groupedDeprecations: computed(function() {
     return {};
-  }).property(),
+  }),
 
   deprecationsToSend: computed(function() {
-    return Ember.A();
+    return A();
   }),
 
   sourceMap: computed(function() {
     return SourceMap.create();
-  }).property(),
+  }),
 
   emberCliConfig: oneWay('namespace.generalDebug.emberCliConfig').readOnly(),
 
-  init: function() {
+  init() {
     this._super();
     this.replaceDeprecate();
   },
@@ -41,13 +38,12 @@ export default EmberObject.extend(PortMixin, {
   /**
    * Checks if ember-cli and looks for source maps.
    */
-  fetchSourceMap: function(stackStr) {
-    var self = this;
+  fetchSourceMap(stackStr) {
     if (this.get('emberCliConfig') && this.get('emberCliConfig.environment') === 'development') {
-      return this.get('sourceMap').map(stackStr).then(function(mapped) {
+      return this.get('sourceMap').map(stackStr).then((mapped) => {
         if (mapped && mapped.length > 0) {
-          var source = mapped.find(function(item) {
-            return !!item.source.match(new RegExp(self.get('emberCliConfig.modulePrefix')));
+          var source = mapped.find(item => {
+            return !!item.source.match(new RegExp(this.get('emberCliConfig.modulePrefix')));
           });
           if (source) {
             source.found = true;
@@ -59,21 +55,20 @@ export default EmberObject.extend(PortMixin, {
         }
       });
     } else {
-      return RSVP.resolve(null, 'ember-inspector');
+      return resolve(null, 'ember-inspector');
     }
 
   },
 
-  sendPending: function() {
-    var self = this;
-    var deprecations = Ember.A();
-
-    var promises = RSVP.all(this.get('deprecationsToSend').map(function(deprecation) {
-      var obj;
-      var promise = RSVP.resolve(undefined, 'ember-inspector');
-      self.get('deprecations').pushObject(deprecation);
-      var grouped = self.get('groupedDeprecations');
-      var id = guidFor(deprecation.message);
+  sendPending() {
+    let deprecations = A();
+
+    let promises = all(this.get('deprecationsToSend').map((deprecation) => {
+      let obj;
+      let promise = resolve(undefined, 'ember-inspector');
+      let grouped = this.get('groupedDeprecations');
+      this.get('deprecations').pushObject(deprecation);
+      const id = guidFor(deprecation.message);
       obj = grouped[id];
       if (obj) {
         obj.count++;
@@ -82,13 +77,13 @@ export default EmberObject.extend(PortMixin, {
         obj = deprecation;
         obj.count = 1;
         obj.id = id;
-        obj.sources = Ember.A();
+        obj.sources = A();
         grouped[id] = obj;
       }
-      var found = obj.sources.findBy('stackStr', deprecation.stackStr);
+      let found = obj.sources.findBy('stackStr', deprecation.stackStr);
       if (!found) {
-        var stackStr = deprecation.stackStr;
-        promise = self.fetchSourceMap(stackStr).then(function(map) {
+        let stackStr = deprecation.stackStr;
+        promise = this.fetchSourceMap(stackStr).then(map => {
           obj.sources.pushObject({
             map: map,
             stackStr: stackStr
@@ -98,34 +93,31 @@ export default EmberObject.extend(PortMixin, {
           }
         }, null, 'ember-inspector');
       }
-      return promise.then(function() {
+      return promise.then(() => {
         delete obj.stackStr;
         deprecations.addObject(obj);
       });
-    }, this));
+    }));
 
-    promises.then(function() {
-      self.sendMessage('deprecationsAdded', {
-        deprecations: deprecations
-      });
-
-      self.get('deprecationsToSend').clear();
-      self.sendCount();
+    promises.then(() => {
+      this.sendMessage('deprecationsAdded', { deprecations });
+      this.get('deprecationsToSend').clear();
+      this.sendCount();
     }, null, 'ember-inspector');
   },
 
-  sendCount: function() {
+  sendCount() {
     this.sendMessage('count', {
       count: this.get('deprecations.length') + this.get('deprecationsToSend.length')
     });
   },
 
   messages: {
-    watch: function() {
+    watch() {
       this._watching = true;
-      var grouped = this.get('groupedDeprecations');
-      var deprecations = [];
-      for (var i in grouped) {
+      let grouped = this.get('groupedDeprecations');
+      let deprecations = [];
+      for (let i in grouped) {
         if (!grouped.hasOwnProperty(i)) {
           continue;
         }
@@ -137,49 +129,49 @@ export default EmberObject.extend(PortMixin, {
       this.sendPending();
     },
 
-    sendStackTraces: function(message) {
-      var deprecation = message.deprecation;
-      deprecation.sources.forEach(function(source) {
-        var stack = source.stackStr;
+    sendStackTraces(message) {
+      let deprecation = message.deprecation;
+      deprecation.sources.forEach(source => {
+        let stack = source.stackStr;
         stack = stack.split('\n');
         stack.unshift('Ember Inspector (Deprecation Trace): ' + (deprecation.message || ''));
         this.get('adapter').log(stack.join('\n'));
-      }, this);
+      });
     },
 
-    getCount: function() {
+    getCount() {
       this.sendCount();
     },
 
-    clear: function() {
+    clear() {
       run.cancel(this.debounce);
       this.get('deprecations').clear();
       this.set('groupedDeprecations', {});
       this.sendCount();
     },
 
-    release: function() {
+    release() {
       this._watching = false;
     }
   },
 
-  willDestroy: function() {
+  willDestroy() {
     Ember.deprecate = this.originalDeprecate;
     this.originalDeprecate = null;
     run.cancel(this.debounce);
     this._super();
   },
 
-  replaceDeprecate: function() {
+  replaceDeprecate() {
     var self = this;
     this.originalDeprecate = Ember.deprecate;
 
     Ember.deprecate = function(message, test, options) {
       /* global __fail__*/
       // Code taken from https://github.com/emberjs/ember.js/blob/master/packages/ember-debug/lib/main.js
-      var noDeprecation;
+      let noDeprecation;
 
-      if (typeof test === 'function' && !(Ember.Object.detect(test))) {
+      if (typeof test === 'function' && !(EmberObject.detect(test))) {
         // try/catch to support old Ember versions
         try { noDeprecation = test(); }
         catch (e) {
@@ -191,13 +183,13 @@ export default EmberObject.extend(PortMixin, {
 
       if (noDeprecation) { return; }
 
-      var error;
+      let error;
 
       // When using new Error, we can't do the arguments check for Chrome. Alternatives are welcome
       try { __fail__.fail(); } catch (e) { error = e; }
 
-      var stack;
-      var stackStr = '';
+      let stack;
+      let stackStr = '';
       if (error.stack) {
 
         // var stack;
@@ -216,12 +208,12 @@ export default EmberObject.extend(PortMixin, {
         stackStr = "\n    " + stack.slice(2).join("\n    ");
       }
 
-      var url;
+      let url;
       if (arguments.length === 3 && options && typeof options === 'object') {
         url = options.url;
       }
 
-      var deprecation = {
+      const deprecation = {
         message: message,
         stackStr: stackStr,
         url: url
diff --git a/ember_debug/general-debug.js b/ember_debug/general-debug.js
index 1ec24397b4..b7fc9abb04 100644
--- a/ember_debug/general-debug.js
+++ b/ember_debug/general-debug.js
@@ -1,10 +1,11 @@
 /* eslint no-empty:0 */
 import PortMixin from "ember-debug/mixins/port-mixin";
-var Ember = window.Ember;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
+const Ember = window.Ember;
+const { $, computed, Object: EmberObject, A } = Ember;
+let { libraries } = Ember;
+const { oneWay } = computed;
 
-var GeneralDebug = Ember.Object.extend(PortMixin, {
+const GeneralDebug = EmberObject.extend(PortMixin, {
   namespace: null,
 
   port: oneWay('namespace.port').readOnly(),
@@ -17,11 +18,10 @@ var GeneralDebug = Ember.Object.extend(PortMixin, {
 
   // Keep an eye on https://github.com/ember-cli/ember-cli/issues/3045
   emberCliConfig: computed(function() {
-    var config;
-    var $ = Ember.$;
-    $('meta[name]').each(function() {
-      var meta = $(this);
-      var match = meta.attr('name').match(/environment$/);
+    let config;
+    $('meta[name]').each(() => {
+      const meta = $(this);
+      let match = meta.attr('name').match(/environment$/);
       if (match) {
         try {
           /* global unescape */
@@ -31,27 +31,26 @@ var GeneralDebug = Ember.Object.extend(PortMixin, {
       }
     });
     return config;
-  }).property(),
+  }),
 
 
-  sendBooted: function() {
+  sendBooted() {
     this.sendMessage('applicationBooted', {
       booted: this.get('application.__inspector__booted')
     });
   },
 
-  sendReset: function() {
+  sendReset() {
     this.sendMessage('reset', {
       reset: true
     });
   },
 
   messages: {
-    applicationBooted: function() {
+    applicationBooted() {
       this.sendBooted();
     },
-    getLibraries: function() {
-      var libraries = Ember.libraries;
+    getLibraries() {
 
       // Ember has changed where the array of libraries is located.
       // In older versions, `Ember.libraries` was the array itself,
@@ -62,16 +61,14 @@ var GeneralDebug = Ember.Object.extend(PortMixin, {
 
       this.sendMessage('libraries', { libraries: arrayize(libraries) });
     },
-    refresh: function() {
+    refresh() {
       window.location.reload();
     }
   }
 });
 
 function arrayize(enumerable) {
-  return Ember.A(enumerable).map(function(item) {
-    return item;
-  });
+  return A(enumerable).map(item => item);
 }
 
 export default GeneralDebug;
diff --git a/ember_debug/libs/promise-assembler.js b/ember_debug/libs/promise-assembler.js
index 6e409b7038..103a63c2f9 100644
--- a/ember_debug/libs/promise-assembler.js
+++ b/ember_debug/libs/promise-assembler.js
@@ -6,34 +6,34 @@
  */
 
 import Promise from 'ember-debug/models/promise';
-var Ember = window.Ember;
+const Ember = window.Ember;
+const { Object: EmberObject, Evented, A, computed, RSVP, copy, isNone } = Ember;
 
-var PromiseAssembler = Ember.Object.extend(Ember.Evented, {
+let PromiseAssembler = EmberObject.extend(Evented, {
   // RSVP lib to debug
-  RSVP: Ember.RSVP,
+  RSVP,
 
-  all: Ember.computed(function() { return Ember.A(); }).property(),
+  all: computed(function() { return A(); }),
 
-  promiseIndex: Ember.computed(function() { return {}; }).property(),
+  promiseIndex: computed(function() { return {}; }),
 
   // injected on creation
   promiseDebug: null,
 
-  start: function() {
+  start() {
     this.RSVP.configure('instrument', true);
-    var self = this;
 
-    this.promiseChained = function(e) {
-      chain.call(self, e);
+    this.promiseChained = (e) => {
+      chain.call(this, e);
     };
-    this.promiseRejected = function(e) {
-      reject.call(self, e);
+    this.promiseRejected = (e) => {
+      reject.call(this, e);
     };
-    this.promiseFulfilled = function(e) {
-      fulfill.call(self, e);
+    this.promiseFulfilled = (e) => {
+      fulfill.call(this, e);
     };
-    this.promiseCreated = function(e) {
-      create.bind(self)(e);
+    this.promiseCreated = (e) => {
+      create.bind(this)(e);
     };
 
     this.RSVP.on('chained', this.promiseChained);
@@ -42,17 +42,17 @@ var PromiseAssembler = Ember.Object.extend(Ember.Evented, {
     this.RSVP.on('created', this.promiseCreated);
   },
 
-  stop: function() {
+  stop() {
     this.RSVP.configure('instrument', false);
     this.RSVP.off('chained', this.promiseChained);
     this.RSVP.off('rejected', this.promiseRejected);
     this.RSVP.off('fulfilled', this.promiseFulfilled);
     this.RSVP.off('created', this.promiseCreated);
 
-    this.get('all').forEach(function(item) {
+    this.get('all').forEach((item) => {
       item.destroy();
     });
-    this.set('all', Ember.A());
+    this.set('all', A());
     this.set('promiseIndex', {});
 
     this.promiseChained = null;
@@ -61,13 +61,13 @@ var PromiseAssembler = Ember.Object.extend(Ember.Evented, {
     this.promiseCreated = null;
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this.stop();
     this._super();
   },
 
-  createPromise: function(props) {
-    var promise = Promise.create(props),
+  createPromise(props) {
+    const promise = Promise.create(props),
         index = this.get('all.length');
 
     this.get('all').pushObject(promise);
@@ -75,9 +75,9 @@ var PromiseAssembler = Ember.Object.extend(Ember.Evented, {
     return promise;
   },
 
-  find: function(guid) {
+  find(guid) {
     if (guid) {
-      var index = this.get('promiseIndex')[guid];
+      const index = this.get('promiseIndex')[guid];
       if (index !== undefined) {
         return this.get('all').objectAt(index);
       }
@@ -86,18 +86,18 @@ var PromiseAssembler = Ember.Object.extend(Ember.Evented, {
     }
   },
 
-  findOrCreate: function(guid) {
+  findOrCreate(guid) {
     return this.find(guid) || this.createPromise({
       guid: guid
     });
   },
 
-  updateOrCreate: function(guid, properties) {
-    var entry = this.find(guid);
+  updateOrCreate(guid, properties) {
+    let entry = this.find(guid);
     if (entry) {
       entry.setProperties(properties);
     } else {
-      properties = Ember.copy(properties);
+      properties = copy(properties);
       properties.guid = guid;
       entry = this.createPromise(properties);
     }
@@ -109,14 +109,14 @@ var PromiseAssembler = Ember.Object.extend(Ember.Evented, {
 export default PromiseAssembler;
 
 PromiseAssembler.reopenClass({
-  supported: function() {
-    return !!Ember.RSVP.on;
+  supported() {
+    return !!RSVP.on;
   }
 });
 
-var fulfill = function(event) {
-  var guid = event.guid;
-  var promise = this.updateOrCreate(guid, {
+const fulfill = function(event) {
+  const guid = event.guid;
+  const promise = this.updateOrCreate(guid, {
     label: event.label,
     settledAt: event.timeStamp,
     state: 'fulfilled',
@@ -128,9 +128,9 @@ var fulfill = function(event) {
 };
 
 
-var reject = function(event) {
-  var guid = event.guid;
-  var promise = this.updateOrCreate(guid, {
+const reject = function(event) {
+  const guid = event.guid;
+  const promise = this.updateOrCreate(guid, {
     label: event.label,
     settledAt: event.timeStamp,
     state: 'rejected',
@@ -143,7 +143,7 @@ var reject = function(event) {
 
 function chain(event) {
   /*jshint validthis:true */
-  var guid = event.guid,
+  const guid = event.guid,
       promise = this.updateOrCreate(guid, {
         label: event.label,
         chainedAt: event.timeStamp
@@ -162,16 +162,16 @@ function chain(event) {
 
 function create(event) {
   /*jshint validthis:true */
-  var guid = event.guid;
+  const guid = event.guid;
 
-  var promise = this.updateOrCreate(guid, {
+  const promise = this.updateOrCreate(guid, {
     label: event.label,
     createdAt: event.timeStamp,
     stack: event.stack
   });
 
   // todo fix ordering
-  if (Ember.isNone(promise.get('state'))) {
+  if (isNone(promise.get('state'))) {
     promise.set('state', 'created');
   }
   this.trigger('created', {
diff --git a/ember_debug/libs/source-map.js b/ember_debug/libs/source-map.js
index 856859df94..f9a6d402ae 100644
--- a/ember_debug/libs/source-map.js
+++ b/ember_debug/libs/source-map.js
@@ -3,13 +3,10 @@
  * A lot of the code is inspired by/taken from
  * https://github.com/evanw/node-source-map-support
  */
-var Ember = window.Ember;
-var EmberObject = Ember.Object;
-var computed = Ember.computed;
-var RSVP = Ember.RSVP;
-var resolve = RSVP.resolve;
+const Ember = window.Ember;
+const { Object: EmberObject, A, computed, RSVP: { resolve, Promise } } = Ember;
 
-var notFoundError = new Error('Source map url not found');
+const notFoundError = new Error('Source map url not found');
 
 export default EmberObject.extend({
 
@@ -24,17 +21,16 @@ export default EmberObject.extend({
    * @param  {String} stack The stack trace
    * @return {RSVP.Promise}
    */
-  map: function(stack) {
-    var self = this;
-    var parsed = Ember.A(fromStackProperty(stack));
-    var array = Ember.A();
-    var lastPromise = null;
-    parsed.forEach(function(item) {
-      lastPromise = self.get('_lastPromise').then(function() {
-        return self.getSourceMap(item.url);
-      }, null, 'ember-inspector').then(function(smc) {
+  map(stack) {
+    const parsed = A(fromStackProperty(stack));
+    let array = A();
+    let lastPromise = null;
+    parsed.forEach(item => {
+      lastPromise = this.get('_lastPromise').then(() => {
+        return this.getSourceMap(item.url);
+      }, null, 'ember-inspector').then(smc => {
         if (smc) {
-          var source = smc.originalPositionFor({
+          let source = smc.originalPositionFor({
             line: item.line,
             column: item.column
           });
@@ -43,7 +39,7 @@ export default EmberObject.extend({
           return array;
         }
       }, null, 'ember-inspector');
-      self.set('_lastPromise', lastPromise);
+      this.set('_lastPromise', lastPromise);
     });
     return resolve(lastPromise, 'ember-inspector').catch(function(e) {
       if (e === notFoundError) {
@@ -57,13 +53,13 @@ export default EmberObject.extend({
     return {};
   }),
 
-  getSourceMap: function(url) {
-    var sourceMaps = this.get('sourceMapCache');
+  getSourceMap(url) {
+    let sourceMaps = this.get('sourceMapCache');
     if (sourceMaps[url] !== undefined) { return resolve(sourceMaps[url], 'ember-inspector'); }
-    return retrieveSourceMap(url).then(function(response) {
+    return retrieveSourceMap(url).then(response => {
       if (response) {
-        var map = JSON.parse(response.map);
-        var sm = new window.sourceMap.SourceMapConsumer(map);
+        const map = JSON.parse(response.map);
+        const sm = new window.sourceMap.SourceMapConsumer(map);
         sourceMaps[url] = sm;
         return sm;
       }
@@ -75,8 +71,8 @@ export default EmberObject.extend({
 
 
 function retrieveSourceMap(source) {
-  var mapURL;
-  return retrieveSourceMapURL(source).then(function(sourceMappingURL) {
+  let mapURL;
+  return retrieveSourceMapURL(source).then((sourceMappingURL) => {
     if (!sourceMappingURL) {
       throw notFoundError;
     }
@@ -86,7 +82,7 @@ function retrieveSourceMap(source) {
     return mapURL;
   })
   .then(retrieveFile)
-  .then(function(sourceMapData) {
+  .then((sourceMapData) => {
     if (!sourceMapData) {
       return null;
     }
@@ -99,15 +95,15 @@ function retrieveSourceMap(source) {
 
 function relativeToAbsolute(file, url) {
   if (!file) { return url; }
-  var dir = file.split('/');
+  let dir = file.split('/');
   dir.pop();
   dir.push(url);
   return dir.join('/');
 }
 
 function retrieveFile(source) {
-  return new RSVP.Promise(function(resolve) {
-    var xhr = new XMLHttpRequest();
+  return new Promise(function(resolve) {
+    const xhr = new XMLHttpRequest();
     xhr.onload = function() {
       resolve(this.responseText, 'ember-inspector');
     };
@@ -118,24 +114,25 @@ function retrieveFile(source) {
 
 function retrieveSourceMapURL(source) {
   return retrieveFile(source).then(function(fileData) {
-    var match = /\/\/[#@]\s*sourceMappingURL=(.*)\s*$/m.exec(fileData);
+    const match = /\/\/[#@]\s*sourceMappingURL=(.*)\s*$/m.exec(fileData);
     if (!match) { return null; }
     return match[1];
   });
 }
 
 
-var UNKNOWN_FUNCTION = "<unknown>";
+const UNKNOWN_FUNCTION = "<unknown>";
 
 // Taken from https://github.com/errorception/browser-stack-parser/
 function fromStackProperty(stackString) {
-  var chrome = /^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
+  const chrome = /^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
       gecko = /^\s*(\S*)(?:\((.*?)\))?@((?:file|http|https).*?):(\d+)(?::(\d+))?\s*$/i,
-      lines = stackString.split('\n'),
-      stack = [],
+      lines = stackString.split('\n');
+
+  let stack = [],
       parts;
 
-  for (var i = 0, j = lines.length; i < j; ++i) {
+  for (let i = 0, j = lines.length; i < j; ++i) {
     if ((parts = gecko.exec(lines[i]))) {
       stack.push({
         url: parts[3],
diff --git a/ember_debug/main.js b/ember_debug/main.js
index 6da75bdb8d..6ea12e3f51 100644
--- a/ember_debug/main.js
+++ b/ember_debug/main.js
@@ -11,9 +11,10 @@ import ContainerDebug from "ember-debug/container-debug";
 import DeprecationDebug from "ember-debug/deprecation-debug";
 import Session from "ember-debug/services/session";
 
-var EmberDebug;
-var Ember = window.Ember;
-EmberDebug = Ember.Object.extend({
+const Ember = window.Ember;
+const { Object: EmberObject, run, Application, namespaces } = Ember;
+
+const EmberDebug = EmberObject.extend({
 
   application: null,
   started: false,
@@ -21,7 +22,7 @@ EmberDebug = Ember.Object.extend({
   Port: Port,
   Adapter: BasicAdapter,
 
-  start: function($keepAdapter) {
+  start($keepAdapter) {
     if (this.get('started')) {
       this.reset($keepAdapter);
       return;
@@ -37,11 +38,10 @@ EmberDebug = Ember.Object.extend({
     this.get("adapter").debug("Ember Inspector Active");
   },
 
-  destroyContainer: function() {
+  destroyContainer() {
     if (this.get('generalDebug')) {
       this.get('generalDebug').sendReset();
     }
-    var self = this;
     ['dataDebug',
     'viewDebug',
     'routeDebug',
@@ -52,27 +52,27 @@ EmberDebug = Ember.Object.extend({
     'deprecationDebug',
     'objectInspector',
     'session'
-    ].forEach(function(prop) {
-      var handler = self.get(prop);
+    ].forEach(prop => {
+      let handler = this.get(prop);
       if (handler) {
-        Ember.run(handler, 'destroy');
-        self.set(prop, null);
+        run(handler, 'destroy');
+        this.set(prop, null);
       }
     });
   },
 
-  startModule: function(prop, Module) {
+  startModule(prop, Module) {
     this.set(prop, Module.create({ namespace: this }));
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this.destroyContainer();
     this._super.apply(this, arguments);
   },
 
-  reset: function($keepAdapter) {
+  reset($keepAdapter) {
     this.destroyContainer();
-    Ember.run(this, function() {
+    run(() => {
       // Adapters don't have state depending on the application itself.
       // They also maintain connections with the inspector which we will
       // lose if we destroy.
@@ -99,7 +99,7 @@ EmberDebug = Ember.Object.extend({
     });
   },
 
-  inspect: function(obj) {
+  inspect(obj) {
     this.get('objectInspector').sendObject(obj);
     this.get('adapter').log('Sent to the Object Inspector');
     return obj;
@@ -108,11 +108,11 @@ EmberDebug = Ember.Object.extend({
 }).create();
 
 function getApplication() {
-  var namespaces = Ember.Namespace.NAMESPACES,
+  let namespaces = Namespace.NAMESPACES,
       application;
 
-  namespaces.forEach(function(namespace) {
-    if (namespace instanceof Ember.Application) {
+  namespaces.forEach((namespace) => {
+    if (namespace instanceof Application) {
       application = namespace;
       return false;
     }
diff --git a/ember_debug/mixins/port-mixin.js b/ember_debug/mixins/port-mixin.js
index 1da07d3a74..6bb75278d8 100644
--- a/ember_debug/mixins/port-mixin.js
+++ b/ember_debug/mixins/port-mixin.js
@@ -1,47 +1,47 @@
-var Ember = window.Ember;
-var Mixin = Ember.Mixin;
+const Ember = window.Ember;
+const { Mixin } = Ember;
 export default Mixin.create({
   port: null,
   messages: {},
 
   portNamespace: null,
 
-  init: function() {
+  init() {
     this.setupPortListeners();
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this.removePortListeners();
   },
 
-  sendMessage: function(name, message) {
+  sendMessage(name, message) {
     this.get('port').send(this.messageName(name), message);
   },
 
-  setupPortListeners: function() {
-    var port = this.get('port'),
+  setupPortListeners() {
+    const port = this.get('port'),
         messages = this.get('messages');
 
-    for (var name in messages) {
+    for (let name in messages) {
       if (messages.hasOwnProperty(name)) {
         port.on(this.messageName(name), this, messages[name]);
       }
     }
   },
 
-  removePortListeners: function() {
-    var port = this.get('port'),
+  removePortListeners() {
+    const port = this.get('port'),
         messages = this.get('messages');
 
-    for (var name in messages) {
+    for (let name in messages) {
       if (messages.hasOwnProperty(name)) {
         port.off(this.messageName(name), this, messages[name]);
       }
     }
   },
 
-  messageName: function(name) {
-    var messageName = name;
+  messageName(name) {
+    let messageName = name;
     if (this.get('portNamespace')) {
       messageName = this.get('portNamespace') + ':' + messageName;
     }
diff --git a/ember_debug/models/profile-manager.js b/ember_debug/models/profile-manager.js
index d15e826cf5..c2cb92836c 100644
--- a/ember_debug/models/profile-manager.js
+++ b/ember_debug/models/profile-manager.js
@@ -1,11 +1,11 @@
 import ProfileNode from './profile-node';
-var Ember = window.Ember;
-var scheduleOnce = Ember.run.scheduleOnce;
+const Ember = window.Ember;
+const { run: { scheduleOnce } } = Ember;
 
 /**
  * A class for keeping track of active rendering profiles as a list.
  */
-var ProfileManager = function() {
+const ProfileManager = function() {
   this.profiles = [];
   this.current = null;
   this.currentSet = [];
@@ -13,14 +13,14 @@ var ProfileManager = function() {
 };
 
 ProfileManager.prototype = {
-  began: function(timestamp, payload, now) {
+  began(timestamp, payload, now) {
     return this.wrapForErrors(this, function() {
       this.current = new ProfileNode(timestamp, payload, this.current, now);
       return this.current;
     });
   },
 
-  ended: function(timestamp, payload, profileNode) {
+  ended(timestamp, payload, profileNode) {
     if (payload.exception) { throw payload.exception; }
     return this.wrapForErrors(this, function() {
       this.current = profileNode.parent;
@@ -35,21 +35,21 @@ ProfileManager.prototype = {
     });
   },
 
-  wrapForErrors: function(context, callback) {
+  wrapForErrors(context, callback) {
     return callback.call(context);
   },
 
-  clearProfiles: function() {
+  clearProfiles() {
     this.profiles.length = 0;
   },
 
-  _profilesFinished: function() {
+  _profilesFinished() {
     return this.wrapForErrors(this, function() {
-      var firstNode = this.currentSet[0],
-        parentNode = new ProfileNode(firstNode.start, { template: 'View Rendering' });
+      const firstNode = this.currentSet[0];
+      let parentNode = new ProfileNode(firstNode.start, { template: 'View Rendering' });
 
       parentNode.time = 0;
-      this.currentSet.forEach(function(n) {
+      this.currentSet.forEach((n) => {
         parentNode.time += n.time;
         parentNode.children.push(n);
       });
@@ -63,16 +63,16 @@ ProfileManager.prototype = {
 
   _profilesAddedCallbacks: undefined, // set to array on init
 
-  onProfilesAdded: function(context, callback) {
+  onProfilesAdded(context, callback) {
     this._profilesAddedCallbacks.push({
       context: context,
       callback: callback
     });
   },
 
-  offProfilesAdded: function(context, callback) {
-    var index = -1, item;
-    for (var i = 0, l = this._profilesAddedCallbacks.length; i < l; i++) {
+  offProfilesAdded(context, callback) {
+    let index = -1, item;
+    for (let i = 0, l = this._profilesAddedCallbacks.length; i < l; i++) {
       item = this._profilesAddedCallbacks[i];
       if (item.context === context && item.callback === callback) {
         index = i;
@@ -83,7 +83,7 @@ ProfileManager.prototype = {
     }
   },
 
-  _triggerProfilesAdded: function(profiles) {
+  _triggerProfilesAdded(profiles) {
     this._profilesAddedCallbacks.forEach(function(item) {
       item.callback.call(item.context, profiles);
     });
diff --git a/ember_debug/models/profile-node.js b/ember_debug/models/profile-node.js
index df1d091154..7ebaf33e02 100644
--- a/ember_debug/models/profile-node.js
+++ b/ember_debug/models/profile-node.js
@@ -3,12 +3,11 @@
 
   @class ProfileNode
 **/
-var Ember = window.Ember;
-var get = Ember.get;
-var guidFor = Ember.guidFor;
+const Ember = window.Ember;
+const { get, guidFor } = Ember;
 
-var ProfileNode = function(start, payload, parent, now) {
-  var name;
+const ProfileNode = function(start, payload, parent, now) {
+  let name;
   this.start = start;
   this.timestamp = now || Date.now();
 
@@ -16,7 +15,7 @@ var ProfileNode = function(start, payload, parent, now) {
     if (payload.template) {
       name = payload.template;
     } else if (payload.view) {
-      var view = payload.view;
+      const view = payload.view;
       name = get(view, 'instrumentDisplay') || get(view, '_debugContainerKey');
       if (name) {
         name = name.replace(/^view:/, '');
@@ -27,7 +26,7 @@ var ProfileNode = function(start, payload, parent, now) {
     if (!name && payload.object) {
       name = payload.object.toString().replace(/:?:ember\d+>$/, '').replace(/^</, '');
       if (!this.viewGuid) {
-        var match = name.match(/:(ember\d+)>$/);
+        const match = name.match(/:(ember\d+)>$/);
         if (match && match.length > 1) {
           this.viewGuid = match[1];
         }
@@ -42,7 +41,7 @@ var ProfileNode = function(start, payload, parent, now) {
 };
 
 ProfileNode.prototype = {
-  finish: function(timestamp) {
+  finish(timestamp) {
     this.time = (timestamp - this.start);
     this.calcDuration();
 
@@ -54,7 +53,7 @@ ProfileNode.prototype = {
     }
   },
 
-  calcDuration: function() {
+  calcDuration() {
     this.duration = Math.round(this.time * 100) / 100;
   }
 };
diff --git a/ember_debug/models/promise.js b/ember_debug/models/promise.js
index 0b8a27e702..6089779ef6 100644
--- a/ember_debug/models/promise.js
+++ b/ember_debug/models/promise.js
@@ -1,13 +1,14 @@
 import computedPolyfill from '../addons/ember-new-computed/index';
-var Ember = window.Ember;
+const Ember = window.Ember;
+const { typeOf, Object: EmberObject, computed, A } = Ember;
 
-var dateComputed = function() {
+const dateComputed = function() {
   return computedPolyfill({
-    get: function() {
+    get() {
       return null;
     },
-    set: function(key, date) {
-      if (Ember.typeOf(date) === 'date') {
+    set(key, date) {
+      if (typeOf(date) === 'date') {
         return date;
       } else if (typeof date === 'number' || typeof date === 'string') {
         return new Date(date);
@@ -17,35 +18,35 @@ var dateComputed = function() {
   });
 };
 
-export default Ember.Object.extend({
+export default EmberObject.extend({
   createdAt: dateComputed(),
   settledAt: dateComputed(),
   chainedAt: dateComputed(),
 
   parent: null,
 
-  children: Ember.computed(function() {
-    return Ember.A();
-  }).property(),
+  children: computed(function() {
+    return A();
+  }),
 
-  level: Ember.computed(function() {
-    var parent = this.get('parent');
+  level: computed('parent.level', function() {
+    const parent = this.get('parent');
     if (!parent) {
       return 0;
     }
     return parent.get('level') + 1;
-  }).property('parent.level'),
+  }),
 
-  isSettled: Ember.computed(function() {
+  isSettled: computed('state', function() {
     return this.get('isFulfilled') || this.get('isRejected');
-  }).property('state'),
+  }),
 
-  isFulfilled: Ember.computed(function() {
+  isFulfilled: computed('state', function() {
     return this.get('state') === 'fulfilled';
-  }).property('state'),
+  }),
 
-  isRejected: Ember.computed(function() {
+  isRejected: computed('state', function() {
     return this.get('state') === 'rejected';
-  }).property('state')
+  })
 
 });
diff --git a/ember_debug/object-inspector.js b/ember_debug/object-inspector.js
index a05f35bcd8..caf8acad4a 100644
--- a/ember_debug/object-inspector.js
+++ b/ember_debug/object-inspector.js
@@ -1,21 +1,12 @@
 import PortMixin from "ember-debug/mixins/port-mixin";
-var Ember = window.Ember;
-var EmberObject = Ember.Object;
-var typeOf = Ember.typeOf;
-var Descriptor = Ember.Descriptor;
-var emberInspect = Ember.inspect;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
-var ComputedProperty = Ember.ComputedProperty;
-var get = Ember.get;
-var set = Ember.set;
-var guidFor = Ember.guidFor;
-var emberMeta = Ember.meta;
-var isNone = Ember.isNone;
-var keys = Ember.keys;
+const Ember = window.Ember;
+const { Object: EmberObject, inspect: emberInspect, meta: emberMeta, typeOf,
+        Descriptor, computed, get, set, ComputedProperty, guidFor, isNone, keys, removeObserver,
+        Mixin, addObserver, cacheFor } = Ember;
+const { oneWay } = computed;
 
 function inspectValue(value) {
-  var string;
+  let string;
   if (value instanceof EmberObject) {
     return { type: "type-ember-object", inspect: value.toString() };
   } else if (isComputed(value)) {
@@ -60,9 +51,13 @@ function inspect(value) {
     // `Ember.inspect` is able to handle this use case,
     // but it is very slow as it loops over all props,
     // so summarize to just first 2 props
-    var ret = [], v, count = 0, broken = false;
-    for (var key in value) {
-      if (!('hasOwnProperty' in value) || value.hasOwnProperty(key)) {
+    let ret = [];
+    let v;
+    let count = 0;
+    let broken = false;
+
+    for (let key in value) {
+      if (value.hasOwnProperty(key)) {
         if (count++ > 1) {
           broken = true;
           break;
@@ -75,7 +70,7 @@ function inspect(value) {
         ret.push(key + ": " + v);
       }
     }
-    var suffix = ' }';
+    let suffix = ' }';
     if (broken) {
       suffix = ' ...}';
     }
@@ -85,7 +80,7 @@ function inspect(value) {
   }
 }
 
-var ObjectInspector = EmberObject.extend(PortMixin, {
+export default EmberObject.extend(PortMixin, {
   namespace: null,
 
   adapter: oneWay('namespace.adapter'),
@@ -94,15 +89,15 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
 
   application: oneWay('namespace.application'),
 
-  init: function() {
+  init() {
     this._super();
     this.set('sentObjects', {});
     this.set('boundObservers', {});
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this._super();
-    for (var objectId in this.sentObjects) {
+    for (let objectId in this.sentObjects) {
       this.releaseObject(objectId);
     }
   },
@@ -116,14 +111,14 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
   portNamespace: 'objectInspector',
 
   messages: {
-    digDeeper: function(message) {
+    digDeeper(message) {
       this.digIntoObject(message.objectId, message.property);
     },
-    releaseObject: function(message) {
+    releaseObject(message) {
       this.releaseObject(message.objectId);
     },
-    calculate: function(message) {
-      var value;
+    calculate(message) {
+      let value;
       value = this.valueForObjectProperty(message.objectId, message.property, message.mixinIndex);
       if (value) {
         this.sendMessage('updateProperty', value);
@@ -135,67 +130,66 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
         errors: errorsToSend(this.get('_errorsFor')[message.objectId])
       });
     },
-    saveProperty: function(message) {
-      var value = message.value;
+    saveProperty(message) {
+      let value = message.value;
       if (message.dataType && message.dataType === 'date') {
         value = new Date(value);
       }
       this.saveProperty(message.objectId, message.mixinIndex, message.property, value);
     },
-    sendToConsole: function(message) {
+    sendToConsole(message) {
       this.sendToConsole(message.objectId, message.property);
     },
-    sendControllerToConsole: function(message) {
-      var container = this.get('application.__container__');
+    sendControllerToConsole(message) {
+      const container = this.get('application.__container__');
       this.sendValueToConsole(container.lookup('controller:' + message.name));
     },
-    sendRouteHandlerToConsole: function(message) {
-      var container = this.get('application.__container__');
+    sendRouteHandlerToConsole(message) {
+      const container = this.get('application.__container__');
       this.sendValueToConsole(container.lookup('route:' + message.name));
     },
-    inspectRoute: function(message) {
-      var container = this.get('application.__container__');
+    inspectRoute(message) {
+      const container = this.get('application.__container__');
       this.sendObject(container.lookup('router:main').router.getHandler(message.name));
     },
-    inspectController: function(message) {
-      var container = this.get('application.__container__');
+    inspectController(message) {
+      const container = this.get('application.__container__');
       this.sendObject(container.lookup('controller:' + message.name));
     },
-    inspectById: function(message) {
-      var obj = this.sentObjects[message.objectId];
+    inspectById(message) {
+      const obj = this.sentObjects[message.objectId];
       this.sendObject(obj);
     },
-    inspectByContainerLookup: function(message) {
-      var container = this.get('application.__container__');
+    inspectByContainerLookup(message) {
+      const container = this.get('application.__container__');
       this.sendObject(container.lookup(message.name));
     },
-    traceErrors: function(message) {
-      var errors = this.get('_errorsFor')[message.objectId];
-      var self = this;
-      toArray(errors).forEach(function(error) {
-        var stack = error.error;
+    traceErrors(message) {
+      let errors = this.get('_errorsFor')[message.objectId];
+      toArray(errors).forEach((error) => {
+        let stack = error.error;
         if (stack && stack.stack) {
           stack = stack.stack;
         } else {
           stack = error;
         }
-        self.get('adapter').log('Object Inspector error for ' + error.property, stack);
+        this.get('adapter').log('Object Inspector error for ' + error.property, stack);
       });
     }
   },
 
-  canSend: function(val) {
+  canSend(val) {
     return (val instanceof EmberObject) || typeOf(val) === 'array';
   },
 
-  saveProperty: function(objectId, mixinIndex, prop, val) {
-    var object = this.sentObjects[objectId];
+  saveProperty(objectId, mixinIndex, prop, val) {
+    let object = this.sentObjects[objectId];
     set(object, prop, val);
   },
 
-  sendToConsole: function(objectId, prop) {
-    var object = this.sentObjects[objectId];
-    var value;
+  sendToConsole(objectId, prop) {
+    let object = this.sentObjects[objectId];
+    let value;
 
     if (isNone(prop)) {
       value = this.sentObjects[objectId];
@@ -206,7 +200,7 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     this.sendValueToConsole(value);
   },
 
-  sendValueToConsole: function(value) {
+  sendValueToConsole(value) {
     window.$E = value;
     if (value instanceof Error) {
       value = value.stack;
@@ -214,12 +208,12 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     this.get("adapter").log('Ember Inspector ($E): ', value);
   },
 
-  digIntoObject: function(objectId, property) {
-    var parentObject = this.sentObjects[objectId],
+  digIntoObject(objectId, property) {
+    let parentObject = this.sentObjects[objectId],
       object = get(parentObject, property);
 
     if (this.canSend(object)) {
-      var details = this.mixinsForObject(object);
+      let details = this.mixinsForObject(object);
 
       this.sendMessage('updateObject', {
         parentObject: objectId,
@@ -232,11 +226,11 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     }
   },
 
-  sendObject: function(object) {
+  sendObject(object) {
     if (!this.canSend(object)) {
       throw new Error("Can't inspect " + object + ". Only Ember objects and arrays are supported.");
     }
-    var details = this.mixinsForObject(object);
+    let details = this.mixinsForObject(object);
     this.sendMessage('updateObject', {
       objectId: details.objectId,
       name: object.toString(),
@@ -247,10 +241,9 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
   },
 
 
-  retainObject: function(object) {
-    var meta = emberMeta(object),
-        guid = guidFor(object),
-        self = this;
+  retainObject(object) {
+    let meta = emberMeta(object);
+    let guid = guidFor(object);
 
     meta._debugReferences = meta._debugReferences || 0;
     meta._debugReferences++;
@@ -259,10 +252,10 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
 
     if (meta._debugReferences === 1 && object.reopen) {
       // drop object on destruction
-      var _oldWillDestroy = object._oldWillDestroy = object.willDestroy;
+      let _oldWillDestroy = object._oldWillDestroy = object.willDestroy;
       object.reopen({
-        willDestroy: function() {
-          self.dropObject(guid);
+        willDestroy: () => {
+          this.dropObject(guid);
           return _oldWillDestroy.apply(this, arguments);
         }
       });
@@ -271,12 +264,12 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     return guid;
   },
 
-  releaseObject: function(objectId) {
-    var object = this.sentObjects[objectId];
+  releaseObject(objectId) {
+    let object = this.sentObjects[objectId];
     if (!object) {
       return;
     }
-    var meta = emberMeta(object),
+    let meta = emberMeta(object),
         guid = guidFor(object);
 
     meta._debugReferences--;
@@ -287,8 +280,8 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
 
   },
 
-  dropObject: function(objectId) {
-    var object = this.sentObjects[objectId];
+  dropObject(objectId) {
+    let object = this.sentObjects[objectId];
 
     if (object.reopen) {
       object.reopen({ willDestroy: object._oldWillDestroy });
@@ -303,28 +296,28 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     this.sendMessage('droppedObject', { objectId: objectId });
   },
 
-  removeObservers: function(objectId) {
-    var observers = this.boundObservers[objectId],
+  removeObservers(objectId) {
+    let observers = this.boundObservers[objectId],
         object = this.sentObjects[objectId];
 
     if (observers) {
-      observers.forEach(function(observer) {
-        Ember.removeObserver(object, observer.property, observer.handler);
+      observers.forEach((observer) => {
+        removeObserver(object, observer.property, observer.handler);
       });
     }
 
     delete this.boundObservers[objectId];
   },
 
-  mixinsForObject: function(object) {
-    var mixins = Ember.Mixin.mixins(object),
+  mixinsForObject(object) {
+    let mixins = Mixin.mixins(object),
         mixinDetails = [];
 
-    var ownProps = propertiesForMixin({ mixins: [{ properties: object }] });
+    let ownProps = propertiesForMixin({ mixins: [{ properties: object }] });
     mixinDetails.push({ name: "Own Properties", properties: ownProps, expand: true });
 
-    mixins.forEach(function(mixin) {
-      var name = mixin[Ember.NAME_KEY] || mixin.ownerConstructor;
+    mixins.forEach((mixin) => {
+      let name = mixin[Ember.NAME_KEY] || mixin.ownerConstructor;
       if (!name) {
         name = 'Unknown mixin';
       }
@@ -334,31 +327,31 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     fixMandatorySetters(mixinDetails);
     applyMixinOverrides(mixinDetails);
 
-    var propertyInfo = null;
-    var debugInfo = getDebugInfo(object);
+    let propertyInfo = null;
+    let debugInfo = getDebugInfo(object);
     if (debugInfo) {
       propertyInfo = getDebugInfo(object).propertyInfo;
       mixinDetails = customizeProperties(mixinDetails, propertyInfo);
     }
 
-    var expensiveProperties = null;
+    let expensiveProperties = null;
     if (propertyInfo) {
       expensiveProperties = propertyInfo.expensiveProperties;
     }
 
-    var objectId = this.retainObject(object);
+    let objectId = this.retainObject(object);
 
-    var errorsForObject = this.get('_errorsFor')[objectId] = {};
+    let errorsForObject = this.get('_errorsFor')[objectId] = {};
     calculateCPs(object, mixinDetails, errorsForObject, expensiveProperties);
 
     this.bindProperties(objectId, mixinDetails);
 
-    var errors = errorsToSend(errorsForObject);
+    let errors = errorsToSend(errorsForObject);
     return { objectId: objectId, mixins: mixinDetails, errors: errors };
   },
 
-  valueForObjectProperty: function(objectId, property, mixinIndex) {
-    var object = this.sentObjects[objectId], value;
+  valueForObjectProperty(objectId, property, mixinIndex) {
+    let object = this.sentObjects[objectId], value;
 
     if (object.isDestroying) {
       value = '<DESTROYED>';
@@ -380,44 +373,41 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
     }
   },
 
-  bindPropertyToDebugger: function(message) {
-    var objectId = message.objectId,
-        property = message.property,
-        mixinIndex = message.mixinIndex,
-        computed = message.computed,
-        self = this;
-
-    var object = this.sentObjects[objectId];
+  bindPropertyToDebugger(message) {
+    let objectId = message.objectId;
+    let property = message.property;
+    let mixinIndex = message.mixinIndex;
+    let computed = message.computed;
+    let object = this.sentObjects[objectId];
 
-    function handler() {
-      var value = get(object, property);
+    let handler = () => {
+      let value = get(object, property);
       value = inspectValue(value);
       value.computed = computed;
 
-      self.sendMessage('updateProperty', {
+      this.sendMessage('updateProperty', {
         objectId: objectId,
         property: property,
         value: value,
         mixinIndex: mixinIndex
       });
-    }
+    };
 
-    Ember.addObserver(object, property, handler);
+    addObserver(object, property, handler);
     this.boundObservers[objectId] = this.boundObservers[objectId] || [];
     this.boundObservers[objectId].push({ property: property, handler: handler });
 
   },
 
-  bindProperties: function(objectId, mixinDetails) {
-    var self = this;
-    mixinDetails.forEach(function(mixin, mixinIndex) {
-      mixin.properties.forEach(function(item) {
+  bindProperties(objectId, mixinDetails) {
+    mixinDetails.forEach((mixin, mixinIndex) => {
+      mixin.properties.forEach((item) => {
         if (item.overridden) {
           return true;
         }
         if (item.value.type !== 'type-descriptor' && item.value.type !== 'type-function') {
-          var computed = !!item.value.computed;
-          self.bindPropertyToDebugger({
+          let computed = !!item.value.computed;
+          this.bindPropertyToDebugger({
             objectId: objectId,
             property: item.name,
             mixinIndex: mixinIndex,
@@ -434,9 +424,9 @@ var ObjectInspector = EmberObject.extend(PortMixin, {
 
 
 function propertiesForMixin(mixin) {
-  var properties = [];
+  let properties = [];
 
-  mixin.mixins.forEach(function(mixin) {
+  mixin.mixins.forEach((mixin) => {
     if (mixin.properties) {
       addProperties(properties, mixin.properties);
     }
@@ -446,7 +436,7 @@ function propertiesForMixin(mixin) {
 }
 
 function addProperties(properties, hash) {
-  for (var prop in hash) {
+  for (let prop in hash) {
     if (!hash.hasOwnProperty(prop)) { continue; }
     if (prop.charAt(0) === '_') { continue; }
 
@@ -455,7 +445,7 @@ function addProperties(properties, hash) {
 
     // when mandatory setter is removed, an `undefined` value may be set
     if (hash[prop] === undefined) { continue; }
-    var options = { isMandatorySetter: isMandatorySetter(hash, prop) };
+    let options = { isMandatorySetter: isMandatorySetter(hash, prop) };
     if (isComputed(hash[prop])) {
       options.readOnly = hash[prop]._readOnly;
     }
@@ -464,7 +454,7 @@ function addProperties(properties, hash) {
 }
 
 function replaceProperty(properties, name, value, options) {
-  var found;
+  let found;
 
   for (var i = 0, l = properties.length; i < l; i++) {
     if (properties[i].name === name) {
@@ -475,18 +465,18 @@ function replaceProperty(properties, name, value, options) {
 
   if (found) { properties.splice(i, 1); }
 
-  var prop = { name: name, value: inspectValue(value) };
+  let prop = { name, value: inspectValue(value) };
   prop.isMandatorySetter = options.isMandatorySetter;
   prop.readOnly = options.readOnly;
   properties.push(prop);
 }
 
 function fixMandatorySetters(mixinDetails) {
-  var seen = {};
-  var propertiesToRemove = [];
+  let seen = {};
+  let propertiesToRemove = [];
 
-  mixinDetails.forEach(function(detail, detailIdx) {
-    detail.properties.forEach(function(property) {
+  mixinDetails.forEach((detail, detailIdx) => {
+    detail.properties.forEach(property => {
       if (property.isMandatorySetter) {
         seen[property.name] = {
           name: property.name,
@@ -501,9 +491,9 @@ function fixMandatorySetters(mixinDetails) {
     });
   });
 
-  propertiesToRemove.forEach(function(prop) {
-    var detail = mixinDetails[prop.detailIdx];
-    var index = detail.properties.indexOf(prop.property);
+  propertiesToRemove.forEach(prop => {
+    let detail = mixinDetails[prop.detailIdx];
+    let index = detail.properties.indexOf(prop.property);
     if (index !== -1) {
       detail.properties.splice(index, 1);
     }
@@ -512,9 +502,9 @@ function fixMandatorySetters(mixinDetails) {
 }
 
 function applyMixinOverrides(mixinDetails) {
-  var seen = {};
-  mixinDetails.forEach(function(detail) {
-    detail.properties.forEach(function(property) {
+  let seen = {};
+  mixinDetails.forEach(detail => {
+    detail.properties.forEach(property => {
       if (Object.prototype.hasOwnProperty(property.name)) { return; }
 
       if (seen[property.name]) {
@@ -529,7 +519,7 @@ function applyMixinOverrides(mixinDetails) {
 }
 
 function isMandatorySetter(object, prop) {
-  var descriptor = Object.getOwnPropertyDescriptor(object, prop);
+  let descriptor = Object.getOwnPropertyDescriptor(object, prop);
   if (descriptor.set && descriptor.set === Ember.MANDATORY_SETTER_FUNCTION) {
     return true;
   }
@@ -539,15 +529,15 @@ function isMandatorySetter(object, prop) {
 function calculateCPs(object, mixinDetails, errorsForObject, expensiveProperties) {
   expensiveProperties = expensiveProperties || [];
 
-  mixinDetails.forEach(function(mixin) {
-    mixin.properties.forEach(function(item) {
+  mixinDetails.forEach(mixin => {
+    mixin.properties.forEach(item => {
       if (item.overridden) {
         return true;
       }
       if (item.value.computed) {
-        var cache = Ember.cacheFor(object, item.name);
+        let cache = cacheFor(object, item.name);
         if (cache !== undefined || expensiveProperties.indexOf(item.name) === -1) {
-          var value = calculateCP(object, item.name, errorsForObject);
+          let value = calculateCP(object, item.name, errorsForObject);
           if (!value || !(value instanceof CalculateCPError)) {
             item.value = inspectValue(value);
             item.value.computed = true;
@@ -614,7 +604,7 @@ function calculateCPs(object, mixinDetails, errorsForObject, expensiveProperties
   ```
 */
 function customizeProperties(mixinDetails, propertyInfo) {
-  var newMixinDetails = [],
+  let newMixinDetails = [],
       neededProperties = {},
       groups = propertyInfo.groups || [],
       skipProperties = propertyInfo.skipProperties || [],
@@ -624,15 +614,15 @@ function customizeProperties(mixinDetails, propertyInfo) {
     mixinDetails[0].expand = false;
   }
 
-  groups.forEach(function(group) {
-    group.properties.forEach(function(prop) {
+  groups.forEach(group => {
+    group.properties.forEach(prop => {
       neededProperties[prop] = true;
     });
   });
 
-  mixinDetails.forEach(function(mixin) {
-    var newProperties = [];
-    mixin.properties.forEach(function(item) {
+  mixinDetails.forEach(mixin => {
+    let newProperties = [];
+    mixin.properties.forEach(item => {
       if (skipProperties.indexOf(item.name) !== -1) {
         return true;
       }
@@ -648,8 +638,8 @@ function customizeProperties(mixinDetails, propertyInfo) {
     }
   });
 
-  groups.slice().reverse().forEach(function(group) {
-    var newMixin = { name: group.name, expand: group.expand, properties: [] };
+  groups.slice().reverse().forEach(group => {
+    let newMixin = { name: group.name, expand: group.expand, properties: [] };
     group.properties.forEach(function(prop) {
       // make sure it's not `true` which means property wasn't found
       if (neededProperties[prop] !== true) {
@@ -664,13 +654,13 @@ function customizeProperties(mixinDetails, propertyInfo) {
 
 
 function getDebugInfo(object) {
-  var debugInfo = null;
+  let debugInfo = null;
   if (object._debugInfo && typeof object._debugInfo === 'function') {
     debugInfo = object._debugInfo();
   }
   debugInfo = debugInfo || {};
-  var propertyInfo = debugInfo.propertyInfo || (debugInfo.propertyInfo = {});
-  var skipProperties = propertyInfo.skipProperties = propertyInfo.skipProperties || (propertyInfo.skipProperties = []);
+  let propertyInfo = debugInfo.propertyInfo || (debugInfo.propertyInfo = {});
+  let skipProperties = propertyInfo.skipProperties = propertyInfo.skipProperties || (propertyInfo.skipProperties = []);
 
   skipProperties.push('isDestroyed', 'isDestroying', 'container');
   // 'currentState' and 'state' are un-observable private properties.
@@ -692,7 +682,7 @@ function getDebugInfo(object) {
   }
 
 
-  for (var prop in object) {
+  for (let prop in object) {
     // remove methods
     if (typeof object[prop] === 'function') {
       skipProperties.push(prop);
@@ -707,9 +697,7 @@ function isComputed(value) {
 }
 
 function toArray(errors) {
-  return keys(errors).map(function(key) {
-    return errors[key];
-  });
+  return keys(errors).map(key => errors[key]);
 }
 
 function calculateCP(object, property, errorsForObject) {
@@ -728,9 +716,8 @@ function calculateCP(object, property, errorsForObject) {
 function CalculateCPError() {}
 
 function errorsToSend(errors) {
-  return toArray(errors).map(function(error) {
+  return toArray(errors).map(error => {
     return { property: error.property };
   });
 }
 
-export default ObjectInspector;
diff --git a/ember_debug/port.js b/ember_debug/port.js
index cfa5859d5b..d8eb2cd248 100644
--- a/ember_debug/port.js
+++ b/ember_debug/port.js
@@ -1,34 +1,32 @@
-var Ember = window.Ember;
-var oneWay = Ember.computed.oneWay;
-var guidFor = Ember.guidFor;
-var run = Ember.run;
+const Ember = window.Ember;
+const { Object: EmberObject, computed, guidFor, run } = Ember;
+const { oneWay } = computed;
 
-export default Ember.Object.extend(Ember.Evented, {
+
+export default EmberObject.extend(Ember.Evented, {
   adapter: oneWay('namespace.adapter').readOnly(),
 
   application: oneWay('namespace.application').readOnly(),
 
-  uniqueId: Ember.computed(function() {
+  uniqueId: computed('application', function() {
     return guidFor(this.get('application')) + '__' + window.location.href + '__' + Date.now();
-  }).property('application'),
+  }),
 
-  init: function() {
-    var self = this;
-    this.get('adapter').onMessageReceived(function(message) {
-      if (self.get('uniqueId') === message.applicationId || !message.applicationId) {
-        self.messageReceived(message.type, message);
+  init() {
+    this.get('adapter').onMessageReceived(message => {
+      if (this.get('uniqueId') === message.applicationId || !message.applicationId) {
+        this.messageReceived(message.type, message);
       }
     });
   },
 
-  messageReceived: function(name, message) {
-    var self = this;
-    this.wrap(function() {
-      self.trigger(name, message);
+  messageReceived(name, message) {
+    this.wrap(() => {
+      this.trigger(name, message);
     });
   },
 
-  send: function(messageType, options) {
+  send(messageType, options) {
     options.type = messageType;
     options.from = 'inspectedWindow';
     options.applicationId = this.get('uniqueId');
@@ -51,7 +49,7 @@ export default Ember.Object.extend(Ember.Evented, {
    * @param {Function} fn
    * @return {Mixed} The return value of the passed function
    */
-  wrap: function(fn) {
+  wrap(fn) {
     return run(this, function() {
       try {
         return fn();
diff --git a/ember_debug/promise-debug.js b/ember_debug/promise-debug.js
index a3e1e2a642..f99d880d4b 100644
--- a/ember_debug/promise-debug.js
+++ b/ember_debug/promise-debug.js
@@ -1,11 +1,9 @@
 import PortMixin from 'ember-debug/mixins/port-mixin';
 import PromiseAssembler from 'ember-debug/libs/promise-assembler';
 import computedPolyfill from './addons/ember-new-computed/index';
-var Ember = window.Ember;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
-var EmberObject = Ember.Object;
-var RSVP = Ember.RSVP;
+const Ember = window.Ember;
+const { computed, Object: EmberObject, RSVP, A, run } = Ember;
+const { oneWay } = computed;
 
 export default EmberObject.extend(PortMixin, {
   namespace: null,
@@ -18,9 +16,9 @@ export default EmberObject.extend(PortMixin, {
   // created on init
   promiseAssembler: null,
 
-  releaseMethods: computed(function() { return Ember.A(); }),
+  releaseMethods: computed(function() { return A(); }),
 
-  init: function() {
+  init() {
     this._super();
     if (PromiseAssembler.supported()) {
       this.set('promiseAssembler', PromiseAssembler.create());
@@ -33,7 +31,7 @@ export default EmberObject.extend(PortMixin, {
 
   delay: 100,
 
-  willDestroy: function() {
+  willDestroy() {
     this.releaseAll();
     if (this.get('promiseAssembler')) {
       this.get('promiseAssembler').destroy();
@@ -43,35 +41,35 @@ export default EmberObject.extend(PortMixin, {
   },
 
   messages: {
-    getAndObservePromises: function() {
+    getAndObservePromises() {
       this.getAndObservePromises();
     },
 
-    supported: function() {
+    supported() {
       this.sendMessage('supported', {
         supported: PromiseAssembler.supported()
       });
     },
 
-    releasePromises: function() {
+    releasePromises() {
       this.releaseAll();
     },
 
-    sendValueToConsole: function(message) {
-      var promiseId = message.promiseId;
-      var promise = this.get('promiseAssembler').find(promiseId);
-      var value = promise.get('value');
+    sendValueToConsole(message) {
+      let promiseId = message.promiseId;
+      let promise = this.get('promiseAssembler').find(promiseId);
+      let value = promise.get('value');
       if (value === undefined) {
         value = promise.get('reason');
       }
       this.get('objectInspector').sendValueToConsole(value);
     },
 
-    tracePromise: function(message) {
-      var id = message.promiseId;
-      var promise = this.get('promiseAssembler').find(id);
+    tracePromise(message) {
+      let id = message.promiseId;
+      let promise = this.get('promiseAssembler').find(id);
       // Remove first two lines and add label
-      var stack = promise.get('stack');
+      let stack = promise.get('stack');
       if (stack) {
         stack = stack.split("\n");
         stack.splice(0, 2, ['Ember Inspector (Promise Trace): ' + (promise.get('label') || '')]);
@@ -79,102 +77,102 @@ export default EmberObject.extend(PortMixin, {
       }
     },
 
-    setInstrumentWithStack: function(message) {
-      var bool = message.instrumentWithStack;
+    setInstrumentWithStack(message) {
+      const bool = message.instrumentWithStack;
       this.set('instrumentWithStack', bool);
       this.setInstrumentWithStack();
     },
 
-    getInstrumentWithStack: function() {
+    getInstrumentWithStack() {
       this.sendInstrumentWithStack();
     }
   },
 
   instrumentWithStack: computedPolyfill({
-    get: function() {
+    get() {
       return !!this.get('session').getItem('promise:stack');
     },
-    set: function(key, value) {
+    set(key, value) {
       this.get('session').setItem('promise:stack', value);
       return value;
     }
   }).property(),
 
-  sendInstrumentWithStack: function() {
+  sendInstrumentWithStack() {
     this.sendMessage('instrumentWithStack', {
       instrumentWithStack: this.get('instrumentWithStack')
     });
   },
 
-  setInstrumentWithStack: function() {
+  setInstrumentWithStack() {
     RSVP.configure('instrument-with-stack', this.get('instrumentWithStack'));
     this.sendInstrumentWithStack();
   },
 
-  releaseAll: function() {
-    this.get('releaseMethods').forEach(function(fn) {
+  releaseAll() {
+    this.get('releaseMethods').forEach(fn => {
       fn();
     });
-    this.set('releaseMethods', Ember.A());
+    this.set('releaseMethods', A());
   },
 
-  getAndObservePromises: function() {
+  getAndObservePromises() {
     this.get('promiseAssembler').on('created', this, this.promiseUpdated);
     this.get('promiseAssembler').on('fulfilled', this, this.promiseUpdated);
     this.get('promiseAssembler').on('rejected', this, this.promiseUpdated);
     this.get('promiseAssembler').on('chained', this, this.promiseChained);
 
-    this.get('releaseMethods').pushObject(function() {
+    this.get('releaseMethods').pushObject(() => {
 
       this.get('promiseAssembler').off('created', this, this.promiseUpdated);
       this.get('promiseAssembler').off('fulfilled', this, this.promiseUpdated);
       this.get('promiseAssembler').off('rejected', this, this.promiseUpdated);
       this.get('promiseAssembler').off('fulfilled', this, this.promiseChained);
 
-    }.bind(this));
+    });
 
     this.promisesUpdated(this.get('promiseAssembler').find());
   },
 
-  updatedPromises: computed(function() { return Ember.A(); }),
+  updatedPromises: computed(function() { return A(); }),
 
   promisesUpdated: function(uniquePromises) {
     if (!uniquePromises) {
-      uniquePromises = Ember.A();
-      this.get('updatedPromises').forEach(function(promise) {
+      uniquePromises = A();
+      this.get('updatedPromises').forEach(promise => {
         uniquePromises.addObject(promise);
       });
     }
     // Remove inspector-created promises
-    uniquePromises = uniquePromises.filter(function(promise) {
+    uniquePromises = uniquePromises.filter(promise => {
       return promise.get('label') !== 'ember-inspector';
     });
-    var serialized = this.serializeArray(uniquePromises);
+    const serialized = this.serializeArray(uniquePromises);
     this.sendMessage('promisesUpdated', {
       promises: serialized
     });
-    this.set('updatedPromises', Ember.A());
+    this.set('updatedPromises', A());
   },
 
-  promiseUpdated: function(event) {
+  promiseUpdated(event) {
     this.get('updatedPromises').pushObject(event.promise);
     Ember.run.debounce(this, 'promisesUpdated', this.delay);
   },
 
-  promiseChained: function(event) {
+  promiseChained(event) {
     this.get('updatedPromises').pushObject(event.promise);
     this.get('updatedPromises').pushObject(event.child);
-    Ember.run.debounce(this, 'promisesUpdated', this.delay);
+    run.debounce(this, 'promisesUpdated', this.delay);
   },
 
-  serializeArray: function(promises) {
-    return promises.map(function(item) {
+  serializeArray(promises) {
+    return promises.map(item => {
       return this.serialize(item);
-    }.bind(this));
+    });
   },
 
-  serialize: function(promise) {
-    var serialized = {};
+  serialize(promise) {
+    let serialized = {};
     serialized.guid = promise.get('guid');
     serialized.state = promise.get('state');
     serialized.label = promise.get('label');
@@ -194,14 +192,14 @@ export default EmberObject.extend(PortMixin, {
     return serialized;
   },
 
-  promiseIds: function(promises) {
-    return promises.map(function(promise) {
+  promiseIds(promises) {
+    return promises.map(promise => {
       return promise.get('guid');
     });
   },
 
-  inspectValue: function(value) {
-    var objectInspector = this.get('objectInspector'),
+  inspectValue(value) {
+    let objectInspector = this.get('objectInspector'),
         inspected = objectInspector.inspectValue(value);
 
     if (inspected.type === 'type-ember-object' || inspected.type === "type-array") {
diff --git a/ember_debug/render-debug.js b/ember_debug/render-debug.js
index 78b5dd38c6..5d392f24a6 100644
--- a/ember_debug/render-debug.js
+++ b/ember_debug/render-debug.js
@@ -1,17 +1,14 @@
 import PortMixin from "ember-debug/mixins/port-mixin";
 import ProfileManager from "ember-debug/models/profile-manager";
 
-var Ember = window.Ember;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
-var later = Ember.run.later;
+const Ember = window.Ember;
+const { computed: { oneWay }, run: { later }, subscribe, Object: EmberObject } = Ember;
 
-var profileManager = new ProfileManager();
-
-var queue = [];
+let profileManager = new ProfileManager();
+let queue = [];
 
 function push(info) {
-  var index = queue.push(info);
+  const index = queue.push(info);
   if (index === 1) {
     later(flush, 50);
   }
@@ -19,7 +16,7 @@ function push(info) {
 }
 
 function flush() {
-  var entry, i;
+  let entry, i;
   for (i = 0; i < queue.length; i++) {
     entry = queue[i];
     if (entry.type === 'began') {
@@ -35,9 +32,9 @@ function flush() {
   queue.length = 0;
 }
 
-Ember.subscribe("render", {
-  before: function(name, timestamp, payload) {
-    var info = {
+subscribe("render", {
+  before(name, timestamp, payload) {
+    const info = {
       type: 'began',
       timestamp: timestamp,
       payload: payload,
@@ -46,19 +43,19 @@ Ember.subscribe("render", {
     return push(info);
   },
 
-  after: function(name, timestamp, payload, beganIndex) {
-    var endedInfo = {
+  after(name, timestamp, payload, beganIndex) {
+    const endedInfo = {
       type: 'ended',
       timestamp: timestamp,
       payload: payload
     };
 
-    var index = push(endedInfo);
+    const index = push(endedInfo);
     queue[beganIndex].endedIndex = index;
   }
 });
 
-export default Ember.Object.extend(PortMixin, {
+export default EmberObject.extend(PortMixin, {
   namespace: null,
   port: oneWay('namespace.port').readOnly(),
   application: oneWay('namespace.application').readOnly(),
@@ -67,18 +64,15 @@ export default Ember.Object.extend(PortMixin, {
 
   profileManager: profileManager,
 
-  init: function() {
-    var self = this;
+  init() {
     this._super();
-    this.profileManager.wrapForErrors = function(context, callback) {
-      return self.get('port').wrap(function() {
-        return callback.call(context);
-      });
+    this.profileManager.wrapForErrors = (context, callback) => {
+      return this.get('port').wrap(() => callback.call(context));
     };
     this._subscribeForViewTrees();
   },
 
-  willDestroy: function() {
+  willDestroy() {
     this._super();
     this.profileManager.wrapForErrors = function(context, callback) {
       return callback.call(context);
@@ -87,13 +81,13 @@ export default Ember.Object.extend(PortMixin, {
     this.profileManager.offProfilesAdded(this, this._updateViewTree);
   },
 
-  _subscribeForViewTrees: function() {
+  _subscribeForViewTrees() {
     this.profileManager.onProfilesAdded(this, this._updateViewTree);
   },
 
-  _updateViewTree: function(profiles) {
-    var viewDurations = {};
-    this._flatten(profiles).forEach(function(node) {
+  _updateViewTree(profiles) {
+    let viewDurations = {};
+    this._flatten(profiles).forEach(node => {
       if (node.viewGuid) {
         viewDurations[node.viewGuid] = node.duration;
       }
@@ -101,31 +95,30 @@ export default Ember.Object.extend(PortMixin, {
     this.get('viewDebug').updateDurations(viewDurations);
   },
 
-  _flatten: function(profiles, array) {
-    var self = this;
+  _flatten(profiles, array) {
     array = array || [];
-    profiles.forEach(function(profile) {
+    profiles.forEach(profile => {
       array.push(profile);
-      self._flatten(profile.children, array);
+      this._flatten(profile.children, array);
     });
     return array;
   },
 
-  sendAdded: function(profiles) {
+  sendAdded(profiles) {
     this.sendMessage('profilesAdded', { profiles: profiles });
   },
 
   messages: {
-    watchProfiles: function() {
+    watchProfiles() {
       this.sendMessage('profilesAdded', { profiles: this.profileManager.profiles });
       this.profileManager.onProfilesAdded(this, this.sendAdded);
     },
 
-    releaseProfiles: function() {
+    releaseProfiles() {
       this.profileManager.offProfilesAdded(this, this.sendAdded);
     },
 
-    clear: function() {
+    clear() {
       this.profileManager.clearProfiles();
       this.sendMessage('profilesUpdated', { profiles: [] });
     }
diff --git a/ember_debug/route-debug.js b/ember_debug/route-debug.js
index d56e456f62..760243ae77 100644
--- a/ember_debug/route-debug.js
+++ b/ember_debug/route-debug.js
@@ -1,27 +1,23 @@
 import PortMixin from 'ember-debug/mixins/port-mixin';
 
-var Ember = window.Ember;
-var classify = Ember.String.classify;
-var dasherize = Ember.String.dasherize;
-var computed = Ember.computed;
-var oneWay = computed.oneWay;
-var observer = Ember.observer;
-var later = Ember.run.later;
-
-export default Ember.Object.extend(PortMixin, {
+const Ember = window.Ember;
+const { String: { classify, dasherize }, computed, observer, run: { later }, Object: EmberObject } = Ember;
+const { oneWay } = computed;
+
+export default EmberObject.extend(PortMixin, {
   namespace: null,
   port: oneWay('namespace.port').readOnly(),
 
   application: oneWay('namespace.application').readOnly(),
 
-  router: computed(function() {
+  router: computed('application', function() {
     return this.get('application.__container__').lookup('router:main');
-  }).property('application'),
+  }),
 
-  applicationController: computed(function() {
-    var container = this.get('application.__container__');
+  applicationController: computed('application', function() {
+    const container = this.get('application.__container__');
     return container.lookup('controller:application');
-  }).property('application'),
+  }),
 
   currentPath: oneWay('applicationController.currentPath').readOnly(),
 
@@ -30,50 +26,49 @@ export default Ember.Object.extend(PortMixin, {
   emberCliConfig: oneWay('namespace.generalDebug.emberCliConfig').readOnly(),
 
   messages: {
-    getTree: function() {
+    getTree() {
       this.sendTree();
     },
-    getCurrentRoute: function() {
+    getCurrentRoute() {
       this.sendCurrentRoute();
     }
   },
 
-  sendCurrentRoute: observer(function() {
-    var self = this;
-    later(function() {
-      self.sendMessage('currentRoute', { name: self.get('currentPath') });
+  sendCurrentRoute: observer('currentPath', function() {
+    later(() => {
+      this.sendMessage('currentRoute', { name: this.get('currentPath') });
     }, 50);
-  }, 'currentPath'),
+  }),
 
-  routeTree: computed(function() {
-    var routeNames = this.get('router.router.recognizer.names');
-    var routeTree = {};
+  routeTree: computed('router', function() {
+    let routeNames = this.get('router.router.recognizer.names');
+    let routeTree = {};
 
-    for (var routeName in routeNames) {
+    for (let routeName in routeNames) {
       if (!routeNames.hasOwnProperty(routeName)) {
         continue;
       }
-      var route = routeNames[routeName];
+      let route = routeNames[routeName];
       buildSubTree.call(this, routeTree, route);
     }
     return arrayizeChildren({ children: routeTree });
-  }).property('router'),
+  }),
 
-  sendTree: function() {
-    var routeTree = this.get('routeTree');
+  sendTree() {
+    const routeTree = this.get('routeTree');
     this.sendMessage('routeTree', { tree: routeTree });
   },
 
-  getClassName: function(name, type) {
-    var container = this.get('application.__container__');
-    var resolver = container.resolver;
+  getClassName(name, type) {
+    let container = this.get('application.__container__');
+    let resolver = container.resolver;
     if (!resolver) {
       resolver = this.get('application.registry.resolver');
     }
-    var prefix = this.get('emberCliConfig.modulePrefix');
-    var podPrefix = this.get('emberCliConfig.podModulePrefix');
-    var usePodsByDefault = this.get('emberCliConfig.usePodsByDefault');
-    var className;
+    let prefix = this.get('emberCliConfig.modulePrefix');
+    let podPrefix = this.get('emberCliConfig.podModulePrefix');
+    let usePodsByDefault = this.get('emberCliConfig.usePodsByDefault');
+    let className;
     if (prefix || podPrefix) {
       // Uses modules
       name = dasherize(name);
@@ -87,7 +82,7 @@ export default Ember.Object.extend(PortMixin, {
           // we don't include the prefix since it's redundant
           // and not part of the file path.
           // (podPrefix - prefix) is part of the file path.
-          var currentPrefix = '';
+          let currentPrefix = '';
           if (podPrefix) {
             currentPrefix = podPrefix.replace(new RegExp('^/?' + prefix + '/?'), '');
           }
@@ -110,16 +105,16 @@ export default Ember.Object.extend(PortMixin, {
 
 });
 
-var buildSubTree = function(routeTree, route) {
-  var handlers = route.handlers;
-  var container = this.get('application.__container__');
-  var subTree = routeTree, item,
+const buildSubTree = function(routeTree, route) {
+  let handlers = route.handlers;
+  let container = this.get('application.__container__');
+  let subTree = routeTree, item,
       routeClassName, routeHandler, controllerName,
       controllerClassName, templateName,
       controllerFactory;
-  for (var i = 0; i < handlers.length; i++) {
+  for (let i = 0; i < handlers.length; i++) {
     item = handlers[i];
-    var handler = item.handler;
+    let handler = item.handler;
     if (subTree[handler] === undefined) {
       routeClassName = this.getClassName(handler, 'route');
 
@@ -163,16 +158,16 @@ var buildSubTree = function(routeTree, route) {
 };
 
 function arrayizeChildren(routeTree) {
-  var obj = {};
+  let obj = {};
   // Top node doesn't have a value
   if (routeTree.value) {
     obj.value = routeTree.value;
   }
 
   if (routeTree.children) {
-    var childrenArray = [];
-    for (var i in routeTree.children) {
-      var route = routeTree.children[i];
+    let childrenArray = [];
+    for (let i in routeTree.children) {
+      let route = routeTree.children[i];
       childrenArray.push(arrayizeChildren(route));
     }
     obj.children = childrenArray;
@@ -182,10 +177,10 @@ function arrayizeChildren(routeTree) {
 }
 
 function getURL(container, segments) {
-  var locationImplementation = container.lookup('router:main').location;
-  var url = [];
-  for (var i = 0; i < segments.length; i++) {
-    var name = null;
+  const locationImplementation = container.lookup('router:main').location;
+  let url = [];
+  for (let i = 0; i < segments.length; i++) {
+    let name = null;
 
     try {
       name = segments[i].generate();
diff --git a/ember_debug/services/session.js b/ember_debug/services/session.js
index 768980abad..3b8107bc99 100644
--- a/ember_debug/services/session.js
+++ b/ember_debug/services/session.js
@@ -1,7 +1,7 @@
-var Ember = window.Ember;
-var EmberObject = Ember.Object;
+const Ember = window.Ember;
+const { Object: EmberObject } = Ember;
 
-var Session = EmberObject.extend({
+const Session = EmberObject.extend({
   setItem: function(/*key, val*/) {},
   removeItem: function(/*key*/) {},
   getItem: function(/*key*/) {}
@@ -12,16 +12,16 @@ if (typeof sessionStorage !== 'undefined') {
   Session.reopen({
     sessionStorage: sessionStorage,
     prefix: '__ember__inspector__',
-    makeKey: function(key) {
+    makeKey(key) {
       return this.prefix + key;
     },
-    setItem: function(key, val) {
+    setItem(key, val) {
       return this.sessionStorage.setItem(this.makeKey(key), val);
     },
-    removeItem: function(key) {
+    removeItem(key) {
       return this.sessionStorage.removeItem(this.makeKey(key));
     },
-    getItem: function(key) {
+    getItem(key) {
       return JSON.parse(this.sessionStorage.getItem(this.makeKey(key)));
     }
   });
diff --git a/ember_debug/view-debug.js b/ember_debug/view-debug.js
index 546e073257..2da98eccc8 100644
--- a/ember_debug/view-debug.js
+++ b/ember_debug/view-debug.js
@@ -1,18 +1,16 @@
 /* eslint no-cond-assign:0 */
 import PortMixin from "ember-debug/mixins/port-mixin";
 
-var Ember = window.Ember;
-var guidFor = Ember.guidFor;
+const Ember = window.Ember;
+const { guidFor, $, computed, run, Object: EmberObject, View, typeOf, Component, ViewUtils, A, keys } = Ember;
+const { later } = run;
+const { oneWay } = computed;
 
-var layerDiv,
+let layerDiv,
     previewDiv,
-    highlightedElement,
-    $ = Ember.$,
-    later = Ember.run.later,
-    computed = Ember.computed,
-    oneWay = computed.oneWay;
+    highlightedElement;
 
-var ViewDebug = Ember.Object.extend(PortMixin, {
+export default EmberObject.extend(PortMixin, {
 
   namespace: null,
 
@@ -30,13 +28,13 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
   portNamespace: 'view',
 
   messages: {
-    getTree: function() {
+    getTree() {
       this.sendTree();
     },
-    hideLayer: function() {
+    hideLayer() {
       this.hideLayer();
     },
-    showLayer: function(message) {
+    showLayer(message) {
       // >= Ember 1.13
       if (message.renderNodeId !== undefined) {
         this._highlightNode(this.get('_lastNodes').objectAt(message.renderNodeId), false);
@@ -45,7 +43,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
         this.showLayer(message.objectId);
       }
     },
-    previewLayer: function(message) {
+    previewLayer(message) {
       // >= Ember 1.13
       if (message.renderNodeId !== undefined) {
         this._highlightNode(this.get('_lastNodes').objectAt(message.renderNodeId), true);
@@ -55,32 +53,32 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       }
 
     },
-    hidePreview: function() {
+    hidePreview() {
       this.hidePreview();
     },
-    inspectViews: function(message) {
+    inspectViews(message) {
       if (message.inspect) {
         this.startInspecting();
       } else {
         this.stopInspecting();
       }
     },
-    inspectElement: function(message) {
+    inspectElement(message) {
       this.inspectElement(message.objectId);
     },
-    setOptions: function(message) {
+    setOptions(message) {
       this.set('options', message.options);
       this.sendTree();
     },
-    sendModelToConsole: function(message) {
-      var model;
+    sendModelToConsole(message) {
+      let model;
       if (message.renderNodeId) {
         // >= Ember 1.13
-        var renderNode = this.get('_lastNodes').objectAt(message.renderNodeId);
+        const renderNode = this.get('_lastNodes').objectAt(message.renderNodeId);
         model = this._modelForNode(renderNode);
       } else {
         // < Ember 1.13
-        var view = this.get('objectInspector').sentObjects[message.viewId];
+        const view = this.get('objectInspector').sentObjects[message.viewId];
         model = this.modelForView(view);
       }
       if (model) {
@@ -89,9 +87,8 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     }
   },
 
-  init: function() {
+  init() {
     this._super();
-    var self = this;
 
     this.viewListener();
     this.retainedObjects = [];
@@ -105,15 +102,15 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     previewDiv.style.display = 'none';
     previewDiv.setAttribute('data-label', 'preview-div');
 
-    $(window).on('resize.' + this.get('eventNamespace'), function() {
+    $(window).on('resize.' + this.get('eventNamespace'), () => {
       if (highlightedElement) {
-        self.highlightView(highlightedElement);
+        this.highlightView(highlightedElement);
       }
     });
   },
 
-  updateDurations: function(durations) {
-    for (var guid in durations) {
+  updateDurations(durations) {
+    for (let guid in durations) {
       if (!durations.hasOwnProperty(guid)) {
         continue;
       }
@@ -122,24 +119,23 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     this.sendTree();
   },
 
-  retainObject: function(object) {
+  retainObject(object) {
     this.retainedObjects.push(object);
     return this.get('objectInspector').retainObject(object);
   },
 
-  releaseCurrentObjects: function() {
-    var self = this;
-    this.retainedObjects.forEach(function(item) {
-      self.get('objectInspector').releaseObject(guidFor(item));
+  releaseCurrentObjects() {
+    this.retainedObjects.forEach(item => {
+      this.get('objectInspector').releaseObject(guidFor(item));
     });
     this.retainedObjects = [];
   },
 
-  eventNamespace: Ember.computed(function() {
+  eventNamespace: computed(function() {
     return 'view_debug_' + guidFor(this);
-  }).property(),
+  }),
 
-  willDestroy: function() {
+  willDestroy() {
     this._super();
     $(window).off(this.get('eventNamespace'));
     $(layerDiv).remove();
@@ -149,32 +145,32 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     this.stopInspecting();
   },
 
-  inspectElement: function(objectId) {
-    var view = this.get('objectInspector').sentObjects[objectId];
+  inspectElement(objectId) {
+    let view = this.get('objectInspector').sentObjects[objectId];
     if (view && view.get('element')) {
       this.get('adapter').inspectElement(view.get('element'));
     }
   },
 
-  sendTree: function() {
-    Ember.run.scheduleOnce('afterRender', this, this.scheduledSendTree);
+  sendTree() {
+    run.scheduleOnce('afterRender', this, this.scheduledSendTree);
   },
 
-  startInspecting: function() {
-    var self = this, viewElem = null;
+  startInspecting() {
+    let viewElem = null;
     this.sendMessage('startInspecting', {});
 
     // we don't want the preview div to intercept the mousemove event
     $(previewDiv).css('pointer-events', 'none');
 
-    $('body').on('mousemove.inspect-' + this.get('eventNamespace'), function(e) {
-      var originalTarget = $(e.target);
-      viewElem = self.findNearestView(originalTarget);
+    $('body').on('mousemove.inspect-' + this.get('eventNamespace'), e => {
+      let originalTarget = $(e.target);
+      viewElem = this.findNearestView(originalTarget);
       if (viewElem) {
-        self.highlightView(viewElem, true);
+        this.highlightView(viewElem, true);
       }
     })
-    .on('mousedown.inspect-' + this.get('eventNamespace'), function() {
+    .on('mousedown.inspect-' + this.get('eventNamespace'), () => {
       // prevent app-defined clicks from being fired
       $(previewDiv).css('pointer-events', '')
       .one('mouseup', function() {
@@ -182,27 +178,27 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
         return pinView();
       });
     })
-    .on('mouseup.inspect-' + this.get('eventNamespace'), function() {
+    .on('mouseup.inspect-' + this.get('eventNamespace'), () => {
       // firefox
       return pinView();
     })
     .css('cursor', '-webkit-zoom-in');
 
-    function pinView() {
+    const pinView = () => {
       if (viewElem) {
-        self.highlightView(viewElem);
-        var view = self.get('objectInspector').sentObjects[viewElem.id];
+        this.highlightView(viewElem);
+        let view = this.get('objectInspector').sentObjects[viewElem.id];
         if (view instanceof Ember.Component) {
-          self.get('objectInspector').sendObject(view);
+          this.get('objectInspector').sendObject(view);
         }
       }
-      self.stopInspecting();
+      this.stopInspecting();
       return false;
-    }
+    };
   },
 
-  findNearestView: function(elem) {
-    var viewElem, view;
+  findNearestView(elem) {
+    let viewElem, view;
     if (!elem || elem.length === 0) { return null; }
     if (elem.hasClass('ember-view')) {
       viewElem = elem.get(0);
@@ -214,7 +210,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     return this.findNearestView($(elem).parents('.ember-view:first'));
   },
 
-  stopInspecting: function() {
+  stopInspecting() {
     $('body')
     .off('mousemove.inspect-' + this.get('eventNamespace'))
     .off('mousedown.inspect-' + this.get('eventNamespace'))
@@ -226,57 +222,54 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     this.sendMessage('stopInspecting', {});
   },
 
-  scheduledSendTree: function() {
-    var self = this;
+  scheduledSendTree() {
     // Send out of band
-    later(function() {
-      if (self.isDestroying) {
+    later(() => {
+      if (this.isDestroying) {
         return;
       }
-      self.releaseCurrentObjects();
-      var tree = self.viewTree();
+      this.releaseCurrentObjects();
+      let tree = this.viewTree();
       if (tree) {
-        self.sendMessage('viewTree', {
+        this.sendMessage('viewTree', {
           tree: tree
         });
       }
     }, 50);
   },
 
-  viewListener: function() {
-    var self = this;
-
-    this.viewTreeChanged = function() {
-      self.sendTree();
-      self.hideLayer();
+  viewListener() {
+    this.viewTreeChanged = () => {
+      this.sendTree();
+      this.hideLayer();
     };
   },
 
-  viewTree: function() {
-    var tree;
-    var emberApp = this.get('application');
+  viewTree() {
+    let tree;
+    let emberApp = this.get('application');
     if (!emberApp) {
       return false;
     }
 
-    var applicationViewId = $(emberApp.rootElement).find('> .ember-view').attr('id');
-    var rootView = this.get('viewRegistry')[applicationViewId];
+    const applicationViewId = $(emberApp.rootElement).find('> .ember-view').attr('id');
+    let rootView = this.get('viewRegistry')[applicationViewId];
     // In case of App.reset view is destroyed
     if (!rootView) {
       return false;
     }
 
-    var children = [];
+    let children = [];
 
     if (!this._isGlimmer()) {
       // before Glimmer
-      var retained = [];
-      var treeId = this.retainObject(retained);
+      let retained = [];
+      let treeId = this.retainObject(retained);
       tree = { value: this.inspectView(rootView, retained), children: children, treeId: treeId };
       this.appendChildren(rootView, children, retained);
     } else {
       this.get('_lastNodes').clear();
-      var renderNode = rootView._renderNode;
+      let renderNode = rootView._renderNode;
       tree = { value: this._inspectNode(renderNode), children: children };
       this._appendNodeChildren(renderNode, children);
     }
@@ -284,9 +277,9 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     return tree;
   },
 
-  modelForView: function(view) {
-    var controller = view.get('controller');
-    var model = controller.get('model');
+  modelForView(view) {
+    const controller = view.get('controller');
+    let model = controller.get('model');
     if (view.get('context') !== controller) {
       model = view.get('context');
     }
@@ -294,27 +287,28 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
   },
 
 
-  inspectView: function(view, retained) {
-    var templateName = view.get('templateName') || view.get('_debugTemplateName'),
-        viewClass = shortViewName(view), name;
+  inspectView(view, retained) {
+    let templateName = view.get('templateName') || view.get('_debugTemplateName');
+    let viewClass = shortViewName(view);
+    let name;
 
-    var tagName = view.get('tagName');
+    let tagName = view.get('tagName');
     if (tagName === '') {
       tagName = '(virtual)';
     }
 
     tagName = tagName || 'div';
 
-    var controller = view.get('controller');
+    const controller = view.get('controller');
 
     name = viewDescription(view);
 
-    var viewId = this.retainObject(view);
+    const viewId = this.retainObject(view);
     retained.push(viewId);
 
-    var timeToRender = this._durations[viewId];
+    const timeToRender = this._durations[viewId];
 
-    var value = {
+    let value = {
       viewClass: viewClass,
       completeViewClass: viewName(view),
       objectId: viewId,
@@ -323,19 +317,19 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       template: templateName || '(inline)',
       tagName: tagName,
       isVirtual: view.get('isVirtual'),
-      isComponent: (view instanceof Ember.Component)
+      isComponent: (view instanceof Component)
     };
 
-    if (controller && !(view instanceof Ember.Component)) {
+    if (controller && !(view instanceof Component)) {
       value.controller = {
         name: shortControllerName(controller),
         completeName: controllerName(controller),
         objectId: this.retainObject(controller)
       };
 
-      var model = this.modelForView(view);
+      let model = this.modelForView(view);
       if (model) {
-        if (Ember.Object.detectInstance(model) || Ember.typeOf(model) === 'array') {
+        if (EmberObject.detectInstance(model) || typeOf(model) === 'array') {
           value.model = {
             name: shortModelName(model),
             completeName: getModelName(model),
@@ -354,43 +348,42 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     return value;
   },
 
-  appendChildren: function(view, children, retained) {
-    var self = this;
-    var childViews = view.get('_childViews');
+  appendChildren(view, children, retained) {
+    const childViews = view.get('_childViews');
 
-    childViews.forEach(function(childView) {
-      if (!(childView instanceof Ember.Object)) { return; }
+    childViews.forEach(childView => {
+      if (!(childView instanceof EmberObject)) { return; }
 
-      if (self.shouldShowView(childView)) {
-        var grandChildren = [];
-        children.push({ value: self.inspectView(childView, retained), children: grandChildren });
-        self.appendChildren(childView, grandChildren, retained);
+      if (this.shouldShowView(childView)) {
+        let grandChildren = [];
+        children.push({ value: this.inspectView(childView, retained), children: grandChildren });
+        this.appendChildren(childView, grandChildren, retained);
       } else {
-        self.appendChildren(childView, children, retained);
+        this.appendChildren(childView, children, retained);
       }
     });
   },
 
-  shouldShowView: function(view) {
+  shouldShowView(view) {
     return (this.options.allViews || this.hasOwnController(view) || this.hasOwnContext(view)) &&
-        (this.options.components || !(view instanceof Ember.Component)) &&
+        (this.options.components || !(view instanceof Component)) &&
         (!view.get('isVirtual') || this.hasOwnController(view) || this.hasOwnContext(view));
   },
 
-  hasOwnController: function(view) {
+  hasOwnController(view) {
     return view.get('controller') !== view.get('_parentView.controller') &&
-    ((view instanceof Ember.Component) || !(view.get('_parentView.controller') instanceof Ember.Component));
+    ((view instanceof Component) || !(view.get('_parentView.controller') instanceof Component));
   },
 
-  hasOwnContext: function(view) {
+  hasOwnContext(view) {
     // Context switching is deprecated, we will need to find a better way for {{#each}} helpers.
     return view.get('context') !== view.get('_parentView.context') &&
       // make sure not a view inside a component, like `{{yield}}` for example.
-      !(view.get('_parentView.context') instanceof Ember.Component);
+      !(view.get('_parentView.context') instanceof Component);
   },
 
-  highlightView: function(element, isPreview) {
-    var range, view, rect;
+  highlightView(element, isPreview) {
+    let range, view, rect;
 
     if (!isPreview) {
       highlightedElement = element;
@@ -399,13 +392,13 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     if (!element) { return; }
 
 
-    if (element instanceof Ember.View) {
+    if (element instanceof View) {
       view = element;
     } else {
       view = this.get('viewRegistry')[element.id];
     }
 
-    var getViewBoundingClientRect = Ember.ViewUtils.getViewBoundingClientRect;
+    let getViewBoundingClientRect = ViewUtils.getViewBoundingClientRect;
     if (getViewBoundingClientRect) {
       // Ember >= 1.9 support `getViewBoundingClientRect`
       rect = getViewBoundingClientRect(view);
@@ -422,13 +415,13 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     }
 
 
-    var templateName = view.get('templateName') || view.get('_debugTemplateName'),
+    let templateName = view.get('templateName') || view.get('_debugTemplateName'),
         controller = view.get('controller'),
         model = controller && controller.get('model'),
         modelName;
 
 
-    var options = {
+    let options = {
       isPreview: isPreview,
       view: {
         name: viewName(view),
@@ -461,10 +454,9 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
   },
 
   // TODO: This method needs a serious refactor/cleanup
-  _highlightRange: function(rect, options) {
-    var div;
-    var isPreview = options.isPreview;
-    var self = this;
+  _highlightRange(rect, options) {
+    let div;
+    let isPreview = options.isPreview;
 
     // take into account the scrolling position as mentioned in docs
     // https://developer.mozilla.org/en-US/docs/Web/API/element.getBoundingClientRect
@@ -496,19 +488,19 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       zIndex: 10000
     });
 
-    var output = "";
+    let output = "";
 
     if (!isPreview) {
       output = "<span class='close' data-label='layer-close'>&times;</span>";
     }
 
-    var template = options.template;
+    let template = options.template;
 
     if (template) {
       output += "<p class='template'><span>template</span>=<span data-label='layer-template'>" + escapeHTML(template.name) + "</span></p>";
     }
-    var view = options.view;
-    var controller = options.controller;
+    let view = options.view;
+    let controller = options.controller;
     if (!view ||!(view.object instanceof Ember.Component)) {
       if (controller) {
         output += "<p class='controller'><span>controller</span>=<span data-label='layer-controller'>" + escapeHTML(controller.name) + "</span></p>";
@@ -520,7 +512,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       output += "<p class='component'><span>component</span>=<span data-label='layer-component'>" + escapeHTML(view.name) + "</span></p>";
     }
 
-    var model = options.model;
+    let model = options.model;
     if (model) {
       output += "<p class='model'><span>model</span>=<span data-label='layer-model'>" + escapeHTML(model.name) + "</span></p>";
     }
@@ -546,8 +538,8 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
         borderRadius: 16,
         textAlign: 'center',
         cursor: 'pointer'
-      }).on('click', function() {
-        self.hideLayer();
+      }).on('click', () => {
+        this.hideLayer();
         return false;
       }).on('mouseup mousedown', function() {
         // prevent re-pinning
@@ -555,43 +547,43 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       });
     }
 
-    $('p.view span:last-child', div).css({ cursor: 'pointer' }).click(function() {
-      self.get('objectInspector').sendObject(view.object);
+    $('p.view span:last-child', div).css({ cursor: 'pointer' }).click(() => {
+      this.get('objectInspector').sendObject(view.object);
     });
 
-    $('p.controller span:last-child', div).css({ cursor: 'pointer' }).click(function() {
-      self.get('objectInspector').sendObject(controller.object);
+    $('p.controller span:last-child', div).css({ cursor: 'pointer' }).click(() => {
+      this.get('objectInspector').sendObject(controller.object);
     });
 
-    $('p.component span:last-child', div).css({ cursor: 'pointer' }).click(function() {
-      self.get('objectInspector').sendObject(view.object);
+    $('p.component span:last-child', div).css({ cursor: 'pointer' }).click(() => {
+      this.get('objectInspector').sendObject(view.object);
     });
 
-    $('p.template span:last-child', div).css({ cursor: 'pointer' }).click(function() {
-      self.inspectElement(guidFor(view.object));
+    $('p.template span:last-child', div).css({ cursor: 'pointer' }).click(() => {
+      this.inspectElement(guidFor(view.object));
     });
 
-    if (model && model.object && ((model.object instanceof Ember.Object) || Ember.typeOf(model.object) === 'array')) {
-      $('p.model span:last-child', div).css({ cursor: 'pointer' }).click(function() {
-        self.get('objectInspector').sendObject(model.object);
+    if (model && model.object && ((model.object instanceof EmberObject) || typeOf(model.object) === 'array')) {
+      $('p.model span:last-child', div).css({ cursor: 'pointer' }).click(() => {
+        this.get('objectInspector').sendObject(model.object);
       });
     }
   },
 
-  showLayer: function(objectId) {
+  showLayer(objectId) {
     this.highlightView(this.get('objectInspector').sentObjects[objectId]);
   },
 
-  previewLayer: function(objectId) {
+  previewLayer(objectId) {
     this.highlightView(this.get('objectInspector').sentObjects[objectId], true);
   },
 
-  hideLayer: function() {
+  hideLayer() {
     layerDiv.style.display = 'none';
     highlightedElement = null;
   },
 
-  hidePreview: function() {
+  hidePreview() {
     previewDiv.style.display = 'none';
   },
 
@@ -603,20 +595,20 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @type {Array}
    */
   _lastNodes: computed(function() {
-    return Ember.A([]);
+    return A([]);
   }),
 
   /**
    * @method isGlimmer
    * @return {Boolean}
    */
-  _isGlimmer: function() {
-    var id = Ember.keys(this.get('viewRegistry'))[0];
+  _isGlimmer() {
+    let id = keys(this.get('viewRegistry'))[0];
     return id && !this.get('viewRegistry')[id].get('_childViews');
   },
 
   viewRegistry: computed('application', function() {
-    return this.get('application.__container__').lookup('-view-registry:main') || Ember.View.views;
+    return this.get('application.__container__').lookup('-view-registry:main') || View.views;
   }),
 
   /**
@@ -625,17 +617,16 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @param  {Array} children
    */
-  _appendNodeChildren: function(renderNode, children) {
-    var self = this;
-    var childNodes = renderNode.childNodes;
+  _appendNodeChildren(renderNode, children) {
+    let childNodes = renderNode.childNodes;
     if (!childNodes) { return; }
-    childNodes.forEach(function(childNode) {
-      if (self._shouldShowNode(childNode, renderNode)) {
-        var grandChildren = [];
-        children.push({ value: self._inspectNode(childNode), children: grandChildren});
-        self._appendNodeChildren(childNode, grandChildren);
+    childNodes.forEach(childNode => {
+      if (this._shouldShowNode(childNode, renderNode)) {
+        let grandChildren = [];
+        children.push({ value: this._inspectNode(childNode), children: grandChildren});
+        this._appendNodeChildren(childNode, grandChildren);
       } else {
-        self._appendNodeChildren(childNode, children);
+        this._appendNodeChildren(childNode, children);
       }
     });
   },
@@ -652,7 +643,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} parentNode
    * @return {Boolean} `true` for show and `false` to skip the node
    */
-  _shouldShowNode: function(renderNode, parentNode) {
+  _shouldShowNode(renderNode, parentNode) {
 
     // Filter out non-(view/components)
     if (!this._nodeIsView(renderNode)) {
@@ -674,8 +665,8 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Object} the model
    */
-  _modelForNode: function(renderNode) {
-    var controller = this._controllerForNode(renderNode);
+  _modelForNode(renderNode) {
+    let controller = this._controllerForNode(renderNode);
     if (controller) {
       return controller.get('model');
     }
@@ -688,7 +679,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Boolean}
    */
-  _nodeIsView: function(renderNode) {
+  _nodeIsView(renderNode) {
     return !!renderNode.state.manager;
   },
 
@@ -701,7 +692,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} parentNode
    * @return {Boolean}
    */
-  _nodeHasOwnController: function(renderNode, parentNode) {
+  _nodeHasOwnController(renderNode, parentNode) {
     return this._controllerForNode(renderNode) !== this._controllerForNode(parentNode);
   },
 
@@ -712,7 +703,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Boolean}
    */
-  _nodeHasViewInstance: function(renderNode) {
+  _nodeHasViewInstance(renderNode) {
     return !!this._viewInstanceForNode(renderNode);
   },
 
@@ -723,7 +714,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Ember.Controller}
    */
-  _controllerForNode: function(renderNode) {
+  _controllerForNode(renderNode) {
     return renderNode.lastResult.scope.locals.controller.value();
   },
 
@@ -735,10 +726,10 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Object} the object containing the required values
    */
-  _inspectNode: function(renderNode) {
-    var name, viewClassName, completeViewClassName, tagName, viewId, timeToRender;
+  _inspectNode(renderNode) {
+    let name, viewClassName, completeViewClassName, tagName, viewId, timeToRender;
 
-    var viewClass = this._viewInstanceForNode(renderNode);
+    let viewClass = this._viewInstanceForNode(renderNode);
 
     if (viewClass) {
       viewClassName = shortViewName(viewClass);
@@ -750,7 +741,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
 
     name = this._nodeDescription(renderNode);
 
-    var value = {
+    let value = {
       template: this._nodeTemplateName(renderNode) || '(inline)',
       name: name,
       objectId: viewId,
@@ -763,7 +754,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
     };
 
 
-    var controller = this._controllerForNode(renderNode);
+    let controller = this._controllerForNode(renderNode);
     if (controller && !(this._nodeIsEmberComponent(renderNode))) {
       value.controller = {
         name: shortControllerName(controller),
@@ -771,9 +762,9 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
         objectId: this.retainObject(controller)
       };
 
-      var model = this._modelForNode(renderNode);
+      let model = this._modelForNode(renderNode);
       if (model) {
-        if (Ember.Object.detectInstance(model) || Ember.typeOf(model) === 'array') {
+        if (EmberObject.detectInstance(model) || Ember.typeOf(model) === 'array') {
           value.model = {
             name: shortModelName(model),
             completeName: getModelName(model),
@@ -802,8 +793,8 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {String} the template name
    */
-  _nodeTemplateName: function(renderNode) {
-    var template = renderNode.lastResult.template;
+  _nodeTemplateName(renderNode) {
+    let template = renderNode.lastResult.template;
     if (template && template.meta && template.meta.moduleName) {
       return template.meta.moduleName.replace(/\.hbs$/, '');
     }
@@ -818,10 +809,10 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {String}
    */
-  _nodeDescription: function(renderNode) {
-    var name;
+  _nodeDescription(renderNode) {
+    let name;
 
-    var viewClass = this._viewInstanceForNode(renderNode);
+    let viewClass = this._viewInstanceForNode(renderNode);
 
     if (viewClass) {
       //. Has a view instance - take the view's name
@@ -831,7 +822,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       }
     } else {
       // Virtual - no view instance
-      var templateName = this._nodeTemplateName(renderNode);
+      let templateName = this._nodeTemplateName(renderNode);
       if (templateName) {
         return templateName.replace(/^.*templates\//, '').replace(/\//g, '.');
       }
@@ -850,7 +841,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Ember.View|Ember.Component} The view or component instance
    */
-  _viewInstanceForNode: function(renderNode) {
+  _viewInstanceForNode(renderNode) {
     return renderNode.emberView;
   },
 
@@ -860,8 +851,8 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @return {Boolean}
    */
-  _nodeIsEmberComponent: function(renderNode) {
-    var viewInstance = this._viewInstanceForNode(renderNode);
+  _nodeIsEmberComponent(renderNode) {
+    let viewInstance = this._viewInstanceForNode(renderNode);
     return !!(viewInstance && (viewInstance instanceof Ember.Component));
   },
 
@@ -871,19 +862,19 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
    * @param  {Object} renderNode
    * @param  {Boolean} isPreview (whether to pin the layer or not)
    */
-  _highlightNode: function(renderNode, isPreview) {
-    var modelName;
+  _highlightNode(renderNode, isPreview) {
+    let modelName;
     // Todo: should be in Ember core
-    var range = document.createRange();
+    let range = document.createRange();
     range.setStartBefore(renderNode.firstNode);
     range.setEndAfter(renderNode.lastNode);
-    var rect = range.getBoundingClientRect();
+    let rect = range.getBoundingClientRect();
 
-    var options = {
+    let options = {
       isPreview: isPreview
     };
 
-    var controller = this._controllerForNode(renderNode);
+    let controller = this._controllerForNode(renderNode);
     if (controller) {
       options.controller = {
         name: controllerName(controller),
@@ -891,14 +882,14 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       };
     }
 
-    var templateName = this._nodeTemplateName(renderNode);
+    let templateName = this._nodeTemplateName(renderNode);
     if (templateName) {
       options.template = {
         name: templateName
       };
     }
 
-    var model;
+    let model;
     if (controller) {
       model = controller.get('model');
     }
@@ -910,7 +901,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
       };
     }
 
-    var view = this._viewInstanceForNode(renderNode);
+    let view = this._viewInstanceForNode(renderNode);
 
     if (view) {
       options.view = {
@@ -924,7 +915,7 @@ var ViewDebug = Ember.Object.extend(PortMixin, {
 });
 
 function viewName(view) {
-  var name = view.constructor.toString(), match;
+  let name = view.constructor.toString(), match;
   if (name.match(/\._/)) {
     name = "virtual";
   } else if (match = name.match(/\(subclass of (.*)\)/)) {
@@ -934,14 +925,14 @@ function viewName(view) {
 }
 
 function shortViewName(view) {
-  var name = viewName(view);
+  let name = viewName(view);
   // jj-abrams-resolver adds `app@view:` and `app@component:`
   // Also `_debugContainerKey` has the format `type-key:factory-name`
   return name.replace(/.*(view|component):(?!$)/, '').replace(/:$/, '');
 }
 
 function getModelName(model) {
-  var name = '<Unknown model>';
+  let name = '<Unknown model>';
   if (model.toString) {
     name = model.toString();
   }
@@ -954,13 +945,14 @@ function getModelName(model) {
 }
 
 function shortModelName(model) {
-  var name = getModelName(model);
+  let name = getModelName(model);
   // jj-abrams-resolver adds `app@model:`
   return name.replace(/<[^>]+@model:/g, '<');
 }
 
 function controllerName(controller) {
-  var className = controller.constructor.toString(), match;
+  let
+   className = controller.constructor.toString(), match;
 
   if (match = className.match(/^\(subclass of (.*)\)/)) {
     className = match[1];
@@ -970,20 +962,20 @@ function controllerName(controller) {
 }
 
 function shortControllerName(controller) {
-  var name = controllerName(controller);
+  let name = controllerName(controller);
   // jj-abrams-resolver adds `app@controller:` at the begining and `:` at the end
   return name.replace(/^.+@controller:/, '').replace(/:$/, '');
 }
 
 function escapeHTML(string) {
-  var div = document.createElement('div');
+  let div = document.createElement('div');
   div.appendChild(document.createTextNode(string));
   return div.innerHTML;
 }
 
 function virtualRange(view) {
-  var start, end;
-  var morph = view.get('morph');
+  let start, end;
+  let morph = view.get('morph');
 
   if (morph) {
     start = $('#' + morph.start)[0];
@@ -995,7 +987,7 @@ function virtualRange(view) {
     end = morph.end;
   }
 
-  var range = document.createRange();
+  let range = document.createRange();
   range.setStartAfter(start);
   range.setEndBefore(end);
 
@@ -1003,7 +995,7 @@ function virtualRange(view) {
 }
 
 function viewDescription(view) {
-  var templateName = view.get('templateName') || view.get('_debugTemplateName'),
+  let templateName = view.get('templateName') || view.get('_debugTemplateName'),
       name, viewClass = shortViewName(view), controller = view.get('controller'),
       parentClassName;
 
@@ -1012,7 +1004,7 @@ function viewDescription(view) {
   } else if (view instanceof Ember.LinkView) {
     name = 'link';
   } else if (view.get('_parentView.controller') === controller || view instanceof Ember.Component) {
-    var viewClassName = view.get('_debugContainerKey');
+    let viewClassName = view.get('_debugContainerKey');
     if (viewClassName) {
       viewClassName = viewClassName.match(/\:(.*)/);
       if (viewClassName) {
@@ -1027,7 +1019,7 @@ function viewDescription(view) {
         viewClassName = viewClass;
       }
 
-      var shortName = viewClassName.match(/(.*)(View|Component)$/);
+      let shortName = viewClassName.match(/(.*)(View|Component)$/);
       if (shortName) {
         viewClassName = shortName[1];
       }
@@ -1036,7 +1028,7 @@ function viewDescription(view) {
       name = Ember.String.camelize(viewClassName);
     }
   } else if (view.get('_parentView.controller') !== controller) {
-    var key = controller.get('_debugContainerKey'),
+    let key = controller.get('_debugContainerKey'),
     className = controller.constructor.toString();
 
     if (key) {
@@ -1056,4 +1048,3 @@ function viewDescription(view) {
   return name;
 }
 
-export default ViewDebug;