Qual è la differenza tra dnode e nowjs?

Question

Come i due confrontare gli uni agli altri?

Answer 1

TL; DR

DNode

• fornisce RMI;
• funzioni a distanza può accettare callback come argomenti;
• che è bello, dal momento che è completamente asincrona;
• corre stand-alone o tramite un server HTTP esistente;
• può avere un browser e client nodo;
• supporti Middleware, proprio come connect;
• è stato più a lungo di quanto NowJS.

NowJS

• va oltre la semplice RMI e implementa un'API "ambito condiviso". E 'come Dropbox , solo con variabili e funzioni, invece di file;
• funzioni remote anche accettare callback ( grazie a Sridatta e Eric da NowJS per la chiarificazione );
• dipende da un server di ascolto HTTP per lavoro;
• può avere solo i client browser;
• è diventato pubblico a poco tempo fa;
• è giusto un po 'buggy ora.

Conclusione

NowJS è più di un giocattolo in questo momento - ma tenere un orologio con la stagionatura. Per roba seria, forse andare con DNode. Per una più dettagliata di questi librerie, leggere insieme.

DNode

DNode fornisce un quadro Method Invocation remoto. Sia il client e il server può esporre funzioni tra loro.

// On the server

var server = DNode(function () {
    this.echo = function (message) {
        console.log(message)
    }
}).listen(9999)

// On the client

dnode.connect(9999, function (server) {
    server.echo('Hello, world!')
})

La funzione che viene passato a DNode() è un gestore non dissimile da quello passato a http.createServer. Ha due parametri: client può essere utilizzato per accedere al funzioni esportate dal cliente e connection possono essere utilizzati per gestire gli eventi relativi alla connessione:

// On the server

var server = DNode(function (client, connection) {
    this.echo = function (message) {
        console.log(message)
        connection.on('end', function () {
            console.log('The connection %s ended.', conn.id)
        })
    }       
}).listen(9999)

I metodi esportati può essere passato qualsiasi cosa, comprese le funzioni. Essi sono adeguatamente avvolto come proxy di DNode e possono essere chiamati a l'altro estremo. Questo è fondamentale: DNode è completamente asincrona; non blocca durante l'attesa per un metodo remoto per tornare:

// A contrived example, of course.
// On the server

var server = DNode(function (client) {
    this.echo = function (message) {
        console.log(message)
        return 'Hello you too.'
    }
}).listen(9999)

// On the client

dnode.connect(9999, function (server) {
    var ret = server.echo('Hello, world!')
    console.log(ret) // This won't work
})

richiamate deve essere passata intorno al fine di ricevere risposte dagli altri endpoint. conversazioni complesse possono diventare illeggibili abbastanza veloce. Questo domanda Discute le soluzioni possibili per questo problema.

// On the server

var server = DNode(function (client, callback) {
    this.echo = function (message, callback) {
        console.log(message)
        callback('Hello you too.')
    }

    this.hello = function (callback) {
        callback('Hello, world!')
    }
}).listen(9999)

// On the client

dnode.connect(9999, function (server) {
    server.echo("I can't have enough nesting with DNode!", function (response) {
        console.log(response)
        server.hello(function (greeting) {
            console.log(greeting)
        })
    })
})

Il client DNode può essere uno script in esecuzione all'interno di un'istanza nodo o può essere incorporato all'interno di una pagina web. In questo caso, si collegherà solo al server che servito la pagina web. Collegare è di grande aiuto in questo caso. Questo scenario è stato testato con tutti i browser moderni e con Internet Explorer 5.5 e 7.

DNode è stato avviato a meno di un anno fa, nel giugno 2010. E 'maturo come un nodo biblioteca può essere. Nel mio test, ho trovato nessun problema evidente.

NowJS

NowJS fornisce una specie di magia API che rasenta essere carino. Il server dispone di un portata everyone.now. Tutto ciò che viene messo all'interno everyone.now diventa visibile ad ogni cliente attraverso la loro portata now.

Questo codice, sul server, condividerà una funzione echo con ogni cliente che scrive un messaggio alla console del server:

// Server-side:

everyone.now.echo = function (message) {
    console.log(message)
}

// So, on the client, one can write:

now.echo('This will be printed on the server console.')

Quando un server-side "condiviso" corre funzione, this avrà un attributo now che è specifico per il cliente che ha fatto quella chiamata.

// Client-side

now.receiveResponse = function (response) {
    console.log('The server said: %s')
}

// We just touched "now" above and it must be synchronized 
// with the server. Will things happen as we expect? Since 
// the code is not multithreaded and NowJS talks through TCP,
// the synchronizing message will get to the server first.
// I still feel nervous about it, though.

now.echo('This will be printed on the server console.')

// Server-side:

everyone.now.echo = function (message) {
    console.log(message)
    this.now.receiveResponse('Thank you for using the "echo" service.')
}

Le funzioni in NowJS può avere valori di ritorno. Per farli, un callback deve essere passato:

// On the client

now.twice(10, function (r) { console.log(r) }

// On the server

everyone.now.twice = function(n) {
    return 2 * n
}

Questa è un'implicazione se si desidera passare un callback come argomento onesto (non per raccogliere un valore di ritorno) - si deve sempre passare la val di ritornocollettore ue, o NowJS possono confondersi. Secondo gli sviluppatori, questo modo di recuperare il valore di ritorno con un callback implicita probabilmente cambierà in futuro:

// On the client

now.crunchSomeNumbers('compute-primes', 

    /* This will be called when our prime numbers are ready to be used. */

    function (data) { /* process the data */ }, 

    /* This will be called when the server function returns. Even if we
    didn't care about our place in the queue, we'd have to add at least
    an empty function. */

    function (queueLength) { alert('You are number ' + queueLength + ' on the queue.') }
)

// On the server

everyone.now.crunchSomeNumbers = function(task, dataCallback) {
    superComputer.enqueueTask(task, dataCallback)
    return superComputer.queueLength
}

E questo è per l'API NowJS. Beh, in realtà ci sono altri 3 funzioni che può essere utilizzato per rilevare connessione client e la disconnessione. Non so il motivo per cui non esporre queste funzioni utilizzando EventEmitter, però.

A differenza DNode, NowJS richiede che il cliente sia uno script in esecuzione all'interno di un browser web. La pagina contenente lo script deve essere servito dallo stesso nodo che esegue il server.

Sul lato server, NowJS ha anche bisogno di un ascolto server HTTP. Si deve essere passato durante l'inizializzazione NowJS:

var server = http.createServer(function (req, response) {
    fs.readFile(__dirname + '/now-client.html', function (err, data) {
        response.writeHead(200, {'Content-Type':'text/html'})  
        response.write(data)
        response.end()
    })
})
server.listen(8080)
var everyone = now.initialize(server)

NowJS prima commettono è da un paio di settimane fa (marzo 2011). Come tale, si aspettano di essere buggy. Ho trovato problemi me stesso durante la scrittura di questa risposta. Si aspettano anche la sua API per cambiare un sacco.

Sul lato positivo, gli sviluppatori sono molto accessibili - Eric mi ha guidato anche a rendere callback lavoro. Il codice sorgente non è documentata, ma è fortunatamente semplice e breve e l'utente guida ed esempi sono sufficienti per ottenere uno iniziare.

Answer 2

membro

NowJS squadra qui. Correzione alla risposta di andref:

NowJS sostiene pienamente "Remote Method Invocation" . È possibile passare funzioni come argomenti di chiamate remote e si può avere funzioni come valori di ritorno pure.

Queste funzioni sono avvolti da NowJS così come sono in DNode modo che siano eseguite sulla macchina su cui è stata definita la funzione. Ciò rende più semplice per esporre nuove funzioni fino alla fine a distanza, proprio come in DNode.

P.S. Inoltre, non so se andref a significare che le chiamate remote sono solo asincrone su DNode. chiamate remote sono anche asincrona su NowJS. Essi non bloccano il vostro codice.

Answer 3

Non ho provato Dnode quindi la mia risposta non è un confronto. Ma vorrei mettere avanti alcune esperienze utilizzando nowjs.

Nowjs si basa su socket.io che è abbastanza buggy. Mi capita spesso sperimento session time-out, si disconnette e eventi now.ready cottura più volte in una breve durata. Scopri questo problema a pagina nowjs Github.

Inoltre ho trovato utilizzando WebSockets non redditizie su alcune piattaforme, tuttavia questo può essere aggirato WebSockets esplicitamente invalidanti.

I aveva previsto la creazione di un app di produzione utilizzando nowjs ma sembra la sua non abbastanza maturo per poter essere invocato. Cercherò dnode se serve il mio scopo, altrimenti farò passare a plain-old express.

Aggiornamento:

sembra da rottamare. Nessun commit dal 8 mesi.