             }
     }
     
+    /// Load a random set of UserViewModels from the data source.
     func fetchUserViewModels() {
+        /// Executes `fetchUserViewModelsAction`, creating a SignalProducer and starting it.
         fetchUserViewModelsAction.apply().start()
     }
     
+    /// Informs UsersViewModel that the UserViewModel at indexPath is now "active" aka on screen.
     func activateIndexPath(indexPath: NSIndexPath) {
         guard let userViewModel = userViewModels?[indexPath.row] else { return }
         if userViewModel.shouldFetchAvatarImage() {
+            /// If the userViewModel is empty, fetch its image.
             self.loadUserViewModelImageProducer(userViewModel).start()
         }
     }
     
+    /// Creates a SignalProducer that first updates the input userViewModel to the loading state, then fetches its image and sends another
+    /// userViewModel in the loaded state. It sends a userViewModel in the error state if the image fails to load.
     private func loadUserViewModelImageProducer(userViewModel: UserViewModel) -> SignalProducer<(UserViewModel, [UserViewModel], [NSIndexPath]), NoError> {
-        return SignalProducer<UserViewModel, NoError>(value: userViewModel)
-            .observeOn(workQueue)
-            .flatMap(FlattenStrategy.Latest, transform: self.loadingImageUserViewModelImageProducer)
-            .observeOn(viewModelsQueue)
+        return SignalProducer<UserViewModel, NoError>(value: userViewModel) /// Lift userViewModel into a SignalProducer so it can be scheduled.
+            .observeOn(workQueue) /// Do the next part on the workQueue.
+            .flatMap(FlattenStrategy.Latest, transform: self.loadingImageUserViewModelImageProducer) /// Transfrom the userViewModel into the loading state.
+            .observeOn(viewModelsQueue) /// Do the next part on the viewModels queue.
             .flatMap(.Latest, transform: { [unowned self] viewModel -> SignalProducer<(UserViewModel, [UserViewModel], [NSIndexPath]), NoError> in
+                /// Grab the latest userViewModels and replace the ones that have changed.
                 guard let userViewModels = self.userViewModels else { return .empty }
                 return self.replaceUserViewModelProducer(viewModel, userViewModels: userViewModels)
             })
             .on(next: { [unowned self] (userViewModel, userViewModels, changedIndexPaths) in
+                /// Actually replace the userViewModels and alert observers which indexPaths were changed.
                 self.userViewModels = userViewModels
                 self.reloadIndexPathsObserver.sendNext(changedIndexPaths)
             })
-            .observeOn(imageQueue)
-            .map { (viewModel: UserViewModel, _, _) in return viewModel }
-            .flatMap(.Latest, transform: self.fetchUserViewModelImageProducer)
-            .observeOn(viewModelsQueue)
+            .observeOn(imageQueue) /// Do the next part on the imageQueue.
+            .map { (viewModel: UserViewModel, _, _) in return viewModel } /// We're only interested in the userViewModel.
+            .flatMap(.Latest, transform: self.fetchUserViewModelImageProducer) /// Fetch the image.
+            .observeOn(viewModelsQueue) /// Do the next part on the viewModels queue.
             .flatMap(.Latest, transform: { [unowned self] (viewModel: UserViewModel) -> SignalProducer<(UserViewModel, [UserViewModel], [NSIndexPath]), NoError> in
+                /// Same deal as above, only this time we're replacing the userViewModel loading state with either the loaded or error state.
                 guard let userViewModels = self.userViewModels else { return .empty }
                 return self.replaceUserViewModelProducer(viewModel, userViewModels: userViewModels)
             })

            })
    }
    
    private func fetchUserViewModelImageProducer(userViewModel: UserViewModel) -> SignalProducer<UserViewModel, NoError> {
        return SignalProducer(value: userViewModel.avatarImageData.input)
            .observeOn(self.imageQueue)
            .flatMap(.Latest, transform: imageController.loadImageDataProducer)
            .map(userViewModel.withData)
            .flatMapError { SignalProducer(value: userViewModel.withError($0)) }
    }
    
    private func loadingImageUserViewModelImageProducer(userViewModel: UserViewModel) -> SignalProducer<UserViewModel, NoError> {
        return SignalProducer(value: userViewModel)
            .map { $0.withLoading(0) }
    }
    
    private func replaceUserViewModelProducer(userViewModel: UserViewModel, userViewModels: [UserViewModel]) -> SignalProducer<(UserViewModel, [UserViewModel], [NSIndexPath]), NoError> {
        return SignalProducer(value: (userViewModel, userViewModels))
            .map { (userViewModel, userViewModels) in
                let newUserViewModelsAndIndicies = userViewModels.enumerate().map { (index, oldUserViewModel) -> (Int?, UserViewModel) in
                    if oldUserViewModel =~= userViewModel {
                        return (index, userViewModel)
                    }
                    return (nil, oldUserViewModel)
                }
                let newUserViewModels = newUserViewModelsAndIndicies.map { $0.1 }
                let changedIndicies = newUserViewModelsAndIndicies.map { $0.0 }.flatMap { $0 }
                let changedIndexPaths = changedIndicies.map { NSIndexPath(forRow: $0, inSection: 0) }
                return (userViewModel, newUserViewModels, changedIndexPaths)
        }
    }

        (reloadIndexPathsSignal, reloadIndexPathsObserver) = Signal<[NSIndexPath], NoError>.pipe()
        
        fetchUserViewModelsAction = Action { [unowned workQueue] _ in
            /// Fetch 100 User objects on workQueue, then transform them into UserViewModels with empty images.
            return SignalProducer(value: 100)
                .observeOn(workQueue)
                .flatMap(.Latest, transform: userController.fetchRandomUsersProducer)
