@defer.inlineCallbacks
    def loadModules(self, filter=[], blacklist=False):
        modules = {}
        pending = []

        # Preserve some old modules if desired
        if filter:
            for name, module in self.modules.items():
                if (name not in filter and not blacklist) or (name in filter and blacklist):
                    modules[name] = module
                    del self.modules[name]

        # Kill old modules
        deferreds = []
        for module in self.modules.values():
            deferreds.append(defer.maybeDeferred(module.stop))
        yield defer.DeferredList(deferreds)

        # Copy over preserved modules
        self.modules = modules

        # Find new modules
        for loader, name, ispkg in pkgutil.iter_modules([self.moddir]):
            if ispkg or name in modules or (filter and not blacklist and name not in filter):
                continue
            try:
                module = getattr(__import__(self.moddir, fromlist=[name]), name)
                reload(module)
                pending.append((name, module))
            except:
                self.err("Failed to import {}.{}", self.moddir, name)

        # Load new modules in order
        while pending:
            remaining = len(pending)
            for name, module in pending:
                loadable = True
                for dependency in module.dependencies:
                    if dependency not in modules:
                        loadable = False
                        break
                if not loadable:
                    continue
                self.modules[name] = module.Module(self)
                self.modules[name].name = name.capitalize()
                self.modules[name].dependencies = module.dependencies
                self.modules[name].log = functools.partial(self.log, cls=name.capitalize())
                self.modules[name].err = functools.partial(self.err, cls=name.capitalize())
                self.modules[name].dispatch = functools.partial(self.dispatch, name)
                pending.remove((name, module))
            if remaining == len(pending):
                unloaded = ", ".join([x[0] for x in pending])
                self.err("Dependency error occured. Failed to load: {}", unloaded)
                break
        self.log("Loaded modules: {}", ", ".join(self.modules.keys()))