Quelle est la différence entre dnode et nowjs?

Question

Comment les deux se comparent-ils l'un à l'autre?

Answer 1

TL;DR

DNode

• fournit RMI;
• les fonctions à distance peut accepter les rappels comme arguments;
• ce qui est agréable, car il est totalement asynchrones;
• fonctionne de manière autonome ou à partir d'un serveur http;
• peut que le navigateur et le Nœud clients;
• prend en charge middleware, tout comme connect;
• a été autour de plus de NowJS.

NowJS

• va au-delà du RMI et met en œuvre une "étendue partagée" de l'API. C'est comme Dropbox, seulement avec des variables et des fonctions à la place de fichiers;
• les fonctions à distance aussi accepter les rappels (grâce à Sridatta et Eric de NowJS pour la précision);
• dépend d'une écoute du serveur http de travail;
• ne peut avoir de clients de navigateur;
• est devenu public très récemment;
• est peu buggé dès maintenant.

Conclusion

NowJS est plus un jouet en ce moment, mais garder une montre comme il mûrit. Pour les choses sérieuses, peut-être aller avec DNode. Pour un examen plus détaillé de ces bibliothèques, de la lecture.

DNode

DNode fournit un Remote method Invocation cadre. À la fois le client et le serveur peuvent exposer les fonctions les unes aux autres.

// 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 fonction qui est passé de DNode() est un gestionnaire pas contrairement à celui passé à http.createServer. Il dispose de deux paramètres: client peut être utilisé pour accéder à la les fonctions exportées par le client et connection peut être utilisé pour gérer liées à la connexion des événements:

// 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)

Les méthodes exportées peuvent être transmis quoi que ce soit, y compris des fonctions. Ils sont bien enveloppé de procurations par la DNode et peut être rappelé à l'autre extrémité. C'est fondamentaux: DNode est entièrement asynchrone; il ne bloque pas lors de l'attente pour une méthode à distance à retourner:

// 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
})

Les rappels doivent être passés dans l'ordre à recevoir les réponses de l'autre point de terminaison. Compliqué les conversations peut devenir illisible assez rapide. Cette question discute des solutions possibles à ce problème.

// 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)
        })
    })
})

Le DNode client peut être un script qui s'exécute à l'intérieur d'un Nœud de l'instance ou peut-être incorporé à l'intérieur d'une page web. Dans ce cas, il suffira de se connecter au serveur servi en de la page web. Connecter est d'une grande aide dans ce cas. Ce scénario a été testé avec tous les navigateurs modernes et avec Internet Explorer 5.5 et 7.

DNode a commencé à moins d'un an, en juin 2010. Il est aussi mature que d'un Nœud la bibliothèque peut être. Dans mes tests, je n'ai trouvé aucun des problèmes évidents.

NowJS

NowJS fournit une sorte de magie de l'API à la limite d'être mignon. Le serveur dispose d'un everyone.now de la portée. Tout ce qui est mis à l'intérieur d' everyone.now devient visible à chaque client par le biais de leur now de la portée.

Ce code, sur le serveur, vous feront partager un echo fonction avec chaque client écrit un message à la console du serveur:

// 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.')

Lorsqu'un serveur-côté "partagé" de la fonction s'exécute, this aura un nowd'attribut qui est spécifique au client à l'origine de cet appel.

// 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.')
}

Fonctions dans NowJS peut avoir les valeurs de retour. Pour les obtenir, un rappel doit être passé:

// On the client

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

// On the server

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

Cela a une implication si vous souhaitez passer un rappel, comme un argument honnête (pas pour recueillir une valeur de retour), il faut toujours passer la valeur de retour collecteur, ou des NowJS peuvent se confondre. Selon les développeurs, ce moyen de récupérer l' valeur de retour avec un rappel implicite va probablement changer dans le futur:

// 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
}

Et c'est ça pour le NowJS API. Eh bien, en fait, il ya 3 autres fonctions peut être utilisé pour détecter client, la connexion et la déconnexion. Je ne sais pas pourquoi ils ne pas exposer ces fonctionnalités à l'aide de EventEmitter, cependant.

Contrairement à DNode, NowJS exige que le client soit un script qui s'exécute dans un navigateur web. La page contenant le script doit être desservis par le même Nœud qui est en cours d'exécution le serveur.

Sur le côté serveur, NowJS aussi besoin d'un serveur http à l'écoute. Il doit être passé lors de l'initialisation de 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 premier commit est à partir d'un il ya quelques semaines (mars 2011). En tant que tel, s'attendre à buggy. J'ai trouvé les questions moi-même lors de l'écriture de cette réponse. Également s'attendre son API de changer beaucoup de choses.

Sur le côté positif, les développeurs sont très accessibles -- Eric a même qui m'a guidé pour faire des rappels de travail. Le code source n'est pas documentée, mais est heureusement simple et court et le guide de l'utilisateur et des exemples suffisent à en démarrer un.

Answer 2

Membre de l'équipe NowJS ici. Correction à la réponse de andref :

NowJS prend en charge complètement "l'Invocation de Méthode à Distance". Vous pouvez passer des fonctions en tant qu'arguments dans des appels distants et vous pouvez également avoir des fonctions en tant que valeurs de retour.

Ces fonctions sont encapsulées par NowJS de la même manière qu'elles le sont dans DNode afin qu'elles soient exécutées sur la machine sur laquelle la fonction a été définie. Cela facilite l'exposition de nouvelles fonctions à l'extrémité distante, tout comme dans DNode.

P.S. De plus, je ne sais pas si andref voulait dire que les appels distants sont uniquement asynchrones sur DNode. Les appels distants sont également asynchrones sur NowJS. Ils ne bloquent pas votre code.

Answer 3

Je n'ai pas essayé Dnode donc ma réponse n'est pas une comparaison. Mais j'aimerais partager quelques expériences en utilisant maintenant.

Maintenant est basé sur socket.io qui est assez bogué. J'éprouve fréquemment des déconnexions, des déconnexions de session et l'événement now.ready se déclenche plusieurs fois en peu de temps. Consultez cette issue sur la page github de maintenant.

J'ai également constaté que l'utilisation des websockets était non viable sur certaines plates-formes, cependant cela peut être contourné en désactivant explicitement les websockets.

J'avais prévu de créer une application de production en utilisant maintenant mais il semble que ce ne soit pas encore assez mature pour être fiable. Je vais essayer dnode si cela convient à mon objectif, sinon je passerai à l'ancien express.

Mise à jour :

Maintenant semble être abandonné. Aucun commit depuis 8 mois.