Gostaria de saber qual é um bom padrão a ser usado quando você pode ter vários xmlhttprequests que fazem parte de diferentes processos como (verificar login, buscar dica de ferramenta e exibir, mostrar sub-registros / abrir detalhes).

A sua opinião sobre o meu código até agora é mais do que bem-vinda, então são alguns bons artigos para referência em manuseio assíncrono de processos.

Aqui está o que eu tenho até agora tentando usar um mediador e tentando definir uma seqüência de eventos a serem acionados pelo mediador e iniciados por um trabalhador para um determinado processo.

var mediator={
    events:[],
// bind functions to events, optionally once only if this function doesn't
// need to handle the event during the lifetime of the application
    addListener:function(name,processor,onceOnly){
        if(!mediator.events[name]){
            mediator.events[name]=new Array({
                processor:processor,
                once: onceOnly ? true : false
                });
            return;
        }
        mediator.events[name].push({
                processor:processor,
                once: onceOnly ? true : false
                });
    },
    trigger:function(name,data){
        var i=0;//check if mediator[name] exist
        for(i=0;i<mediator.events[name].length;i++){
            try{
                mediator.events[name][i].processor(data);
// problem is when a use once handler is the 3rd in the chain and the
// second handler fails then the 3rd is never removed
// could trigger an error here that has a cleaner listner
            }finally{
                if(mediator.events[name][i].once){
                    mediator.remove(name,mediator.events[name][i]);
                }
            }
        }
    },
// removing listener from event
    remove:function(name,event){
        for(var i=0;i<mediator.events[name].length;i++){
            if(mediator.events[name][i]==event){
                mediator.events[name].splice(i,1);
                return;
            }
        }
    },
// used to provide an event chain through data that will execute a certain
// process
    triggerNext:function(data){
        // some checks on data
        mediator.trigger(data.events[data.index++],data);
    }
}
// possible response parsers
var parser=function(type){
    var parseLogin=function(data){
        console.log(data);
// should call triggerNext here for the worker to be notified.
    }
    if(type=="loginParser"){
        return parseLogin;
    }
}
// connects and triggers next
var connector=function(){
    this.response="";
    this.commObject=null;
    this.connect=function(data){
        $.get(data.url, function(res) {
            data.commObject=this;//maybe you'd like to inpect it
            data.response=res;
            mediator.triggerNext(data);
        });//trigger fail event if failed
    };
}
// example of initiating a process
$("document").ready(function(){
//add all listeners that are used during the entire execution 
// of the application here
    var p=parser("loginParser");
    mediator.addListener("checkLogin",p);
//the following is a temporary listener, this code would be in
// a worker object initLogin function.
    var c=new connector();
    mediator.addListener("connect",c.connect,true);
// the data determines what process will be invoked
// this could be in a worker.initLogin function
    var data={
        processType:"SendLoginAndCheck",
        url:"test.html",
        post:"",//could check in the connector.connect to see if post is set
        events:["connect","checkLogin"],
//there is no worker.afterLogin but the 3rd event could be finishprocess
//and a worker object's function can be called to process that
        index:0
    }
//start the process
    mediator.triggerNext(data);
});