diff --git a/platform/commonUI/general/src/ActionGroupController.js b/platform/commonUI/general/src/ActionGroupController.js
index 339e10dd97..d8bae651ae 100644
--- a/platform/commonUI/general/src/ActionGroupController.js
+++ b/platform/commonUI/general/src/ActionGroupController.js
@@ -9,10 +9,24 @@ define(
         "use strict";
 
         /**
+         * Controller which keeps an up-to-date list of actions of
+         * a certain category, and additionally bins them into
+         * groups as described by their metadata. Used specifically
+         * to support button groups.
+         *
+         * This will maintain two fields in the scope:
+         * * `groups`: An array of arrays. Each element in the outer
+         *   array corresponds to a group; the inner array contains
+         *   the actions which are in that group.
+         * * `ungrouped`: All actions which did not have a defined
+         *   group.
          *
          * @constructor
          */
         function ActionGroupController($scope) {
+
+            // Separate out the actions that have been retrieved
+            // into groups, and populate scope with this.
             function groupActions(actions) {
                 var groups = {},
                     ungrouped = [];
@@ -36,20 +50,31 @@ define(
                 });
             }
 
+            // Callback for when state which might influence action groupings
+            // changes.
             function updateGroups() {
                 var actionCapability = $scope.action,
                     params = $scope.parameters || {},
                     category = params.category;
 
                 if (actionCapability && category) {
-                    groupActions(actionCapability.getActions({ category: category }));
+                    // Get actions by capability, and group them
+                    groupActions(actionCapability.getActions({
+                        category: category
+                    }));
+                } else {
+                    // We don't have enough information to get any actions.
+                    groupActions([]);
                 }
             }
 
+            // Changes to the represented object, to its action capability, or
+            // to the chosen action category may all require an update.
             $scope.$watch("domainObject", updateGroups);
             $scope.$watch("action", updateGroups);
             $scope.$watch("parameters.category", updateGroups);
 
+            // Start with empty arrays.
             $scope.ungrouped = [];
             $scope.groups = [];
         }
diff --git a/platform/commonUI/general/src/ContextMenuController.js b/platform/commonUI/general/src/ContextMenuController.js
index a3dcbf1ae9..ba05c08c8b 100644
--- a/platform/commonUI/general/src/ContextMenuController.js
+++ b/platform/commonUI/general/src/ContextMenuController.js
@@ -9,16 +9,20 @@ define(
         "use strict";
 
         /**
+         * Controller for the context menu. Maintains an up-to-date
+         * list of applicable actions (those from category "contextual")
          *
          * @constructor
          */
         function ContextMenuController($scope) {
+            // Refresh variable "menuActions" in the scope
             function updateActions() {
                 $scope.menuActions = $scope.action ?
                         $scope.action.getActions({ category: 'contextual' }) :
                         [];
             }
 
+            // Update using the action capability
             $scope.$watch("action", updateActions);
         }
 
diff --git a/platform/commonUI/general/src/MCTContainer.js b/platform/commonUI/general/src/MCTContainer.js
index f8bba684bd..c8dd92d397 100644
--- a/platform/commonUI/general/src/MCTContainer.js
+++ b/platform/commonUI/general/src/MCTContainer.js
@@ -9,6 +9,14 @@ define(
         "use strict";
 
         /**
+         * The mct-container is similar to the mct-include directive
+         * insofar as it allows templates to be referenced by
+         * symbolic keys instead of by URL. Unlike mct-include, it
+         * supports transclusion.
+         *
+         * Unlike mct-include, mct-container accepts a key as a
+         * plain string attribute, instead of as an Angular
+         * expression.
          *
          * @constructor
          */
@@ -27,9 +35,18 @@ define(
             });
 
             return {
+
+                // Allow only at the element level
                 restrict: 'E',
+
+                // Support transclusion
                 transclude: true,
+
+                // Create a new (non-isolate) scope
                 scope: true,
+
+                // Populate initial scope based on attributes requested
+                // by the container definition
                 link: function (scope, element, attrs) {
                     var key = attrs.key,
                         container = containerMap[key],
@@ -45,10 +62,14 @@ define(
 
                     scope[alias] = copiedAttributes;
                 },
+
+                // Get the template URL for this container, based
+                // on its attributes.
                 templateUrl: function (element, attrs) {
                     var key = attrs.key;
                     return containerMap[key].templateUrl;
                 }
+
             };
         }